<!DOCTYPE html>
<html lang="en-US">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>train_model_components [HALCON算子参考手册]</title>
<style type="text/css">
      body {
    color: #000000;
    background-color: #ffffff;
    margin: 0;
    font-family: Arial, Helvetica, sans-serif;
}

.body_main {
    margin-left: 35px;
    margin-right: 35px;
}

@media screen and (min-width:992px) {

    .body_main {
        margin-left: 10%;
        margin-right: 10%;
    }

    table.toctable {
        width: 80%
    }
}

@media screen and (min-width:1400px) {

    .body_main {
        margin-left: 15%;
        margin-right: 15%;
    }

    table.toctable {
        width: 70%
    }
}

body>div ul ul {
    margin-left: inherit;
}

a:link {
    color: #0044cc;
}

a:link,
a:visited {
    text-decoration: none;
}

a:link:hover,
a:visited:hover {
    text-decoration: underline;
}

th {
    text-align: left;
}

h1,
h2,
h3,
h4,
h5,
h6 {
    text-rendering: optimizeLegibility;
    color: #666666;
}

code {
    font-family: monospace,monospace;
}

h1 a.halconoperator {
    font-family: Arial, Helvetica, sans-serif;
    color: #666666;
}

h2 a.halconoperator {
    font-family: Arial, Helvetica, sans-serif;
    color: #666666;
}

hr {
    border: 0;
    border-top: solid 1px #f28d26;
}

.pre {
    display: block;
    padding-bottom: 1ex;
    font-family: monospace;
    white-space: pre;
}

pre {
    font-family: monospace, monospace;
    padding: 1ex;
    white-space: pre-wrap;
}

.toc {
    font-size: 80%;
    border-top: 1px dashed #f28d26;
    border-bottom: 1px dashed #f28d26;
    padding-top: 5px;
    padding-bottom: 5px;
}

.inv {
    margin: 0;
    border: 0;
    padding: 0;
}

.banner {
    color: #666666;
    padding-left: 1em;
}

.logo {
    background-color: white;
}

.keyboard {
    font-size: 80%;
    padding-left: 3px;
    padding-right: 3px;
    border-radius: 5px;
    border-width: 1px;
    border-style: solid;
    border-color: #f28d26;
    background-color: #f3f3f3;
}

.warning {
    margin-top: 2ex;
    margin-bottom: 1ex;
    padding: 10px;
    text-align: center;
    border: 1px solid;
    color: #bb0000;
    background-color: #fff7f7
}

.imprint {
    margin-top: 1ex;
    font-size: 80%;
    color: #666666;
}

.imprinthead {
    font-weight: bolder;
    color: #666666;
}

.indexlink {
    text-align: right;
    padding-bottom: 5px;
}

.postscript {
    margin-top: 2ex;
    font-size: 80%;
    color: #666666
}

.evenrow {
    background-color: #e7e7ef;
    vertical-align: top;
}

.oddrow {
    background-color: #f7f7ff;
    vertical-align: top;
}

.headrow {
    background-color: #97979f;
    color: #ffffff;
    vertical-align: top;
}

.logorow {
    vertical-align: top;
}

.error {
    color: red;
}

.var {
    font-style: italic
}

.halconoperator {
    font-family: monospace, monospace;
}

span.operator {
    font-family: monospace, monospace;
}

span.procedure {
    font-family: monospace, monospace;
}

span.operation {
    font-family: monospace, monospace;
}

span.feature {
    font-family: Arial, Helvetica, Homerton, sans-serif;
}

ul {
    padding-left: 1.2em;
}

li.dot {
    list-style-type: square;
    color: #f28d26;
}

.breadcrumb {
    font-size: 80%;
    color: white;
    background-color: #062d64;
    margin-bottom: 20px;
    padding-left: 35px;
    padding-right: 35px;
    padding-bottom: 15px;
}

.webbar {
    font-size: 80%;
    background-color: #dddddd;
    margin-top: 0px;
    margin-left: -35px;
    margin-right: -35px;
    margin-bottom: 0px;
    padding-top: 5px;
    padding-left: 35px;
    padding-right: 35px;
    padding-bottom: 5px;
}

.footer {
    display: flex;
    flex-wrap: wrap;
    justify-content: space-between;
    border-top: 1px dashed #f28d26;
    font-size: 80%;
    color: #666666;
    padding-bottom: 8px;
}

.footer .socialmedia a {
    padding-left: 7px;
}

.socialmedia {
    padding-top: 10px;
}

.copyright {
    margin-top: 19px;
}

.breadcrumb a {
    color: #ffffff;
    border-bottom: 1px solid white;
}

.breadcrumb a:link:hover,
.breadcrumb a:visited:hover {
    text-decoration: none;
    border-bottom: none;
}

.heading {
    margin-top: 1ex;
    font-size: 110%;
    font-weight: bold;
    color: #666666;
}

.text {
    color: black;
}

.example {
    font-size: 80%;
    background-color: #f3f3f3;
    border: 1px dashed #666666;
    padding: 10px;
}

.displaymath {
    display: block;
    text-align: center;
    margin-top: 1ex;
    margin-bottom: 1ex;
}

.title {
    float: left;
    padding-top: 3px;
    padding-bottom: 3px;
}

.signnote {
    font-family: Arial, Helvetica, Homerton, sans-serif;
    font-size: 80%;
    color: #666666;
    font-weight: lighter;
    font-style: italic
}

.par {
    margin-bottom: 1.5em;
}

.parhead {
    text-align: right;
}

.parname {
    float: left;
}

.pardesc {
    font-size: 85%;
    margin-top: 0.5em;
    margin-bottom: 0.5em;
    margin-left: 2em;
}

.parcat {
    color: #666;
    font-weight: bold;
}

*[data-if=cpp],
*[data-if=c],
*[data-if=dotnet],
*[data-if=com],
*[data-if=python] {
    display: none;
}

.tabbar {
    text-align: right;
    border-bottom: 1px solid #f28d26;
    margin-bottom: 0.5em;
}

ul.tabs {
    padding-top: 3px;
    padding-bottom: 3px;
    margin-top: 10px;
    margin-bottom: 0;
    font-size: 80%
}

ul.tabs li {
    padding-top: 3px;
    padding-bottom: 3px;
    display: inline;
    overflow: hidden;
    list-style-type: none;
    margin: 0;
    margin-left: 8px;
    border-top: 1px solid #666;
    border-left: 1px solid #666;
    border-right: 1px solid #666;
}

ul.tabs li.active {
    border-left: 1px solid #f28d26;
    border-right: 1px solid #f28d26;
    border-top: 1px solid #f28d26;
    border-bottom: 1px solid #fff;
}

ul.tabs li.inactive {
    background-color: #eee;
}

ul.tabs li a {
    padding-left: 5px;
    padding-right: 5px;
    color: #666;
}

ul.tabs li a:link:hover {
    text-decoration: none;
}

ul.tabs li.inactive a {
    color: #666;
}

ul.tabs li.active a {
    color: black;
}

dl.generic dd {
    margin-bottom: 1em;
}

.pari {
    color: olive;
}

.paro {
    color: maroon;
}

.comment {
    font-size: 80%;
    color: green;
    white-space: nowrap;
}

table.grid {
    border-collapse: collapse;
}

table.grid td {
    padding: 5px;
    border: 1px solid;
}

table.layout {
    border: 0px;
}

table.layout td {
    padding: 5px;
}

table.table {
    border-collapse: collapse;
}

table.table td {
    padding: 5px;
    border-left: 0px;
    border-right: 0px;
}

table.table tr:last-child {
    border-bottom: 1px solid;
}

table.table th {
    padding: 5px;
    border-top: 1px solid;
    border-bottom: 1px solid;
    border-left: 0px;
    border-right: 0px;
}

.details_summary {
    cursor: pointer;
}

table.toctable {
    width: 100%;
}

table.toctable col:first-child {
    width: 20%;
}

table.toctable col:nth-last-child(2) {
    width: 8%;
}

table.altcolored tr:nth-child(even) {
    background-color: #f3f3f3;
}

    </style>
<!--OP_REF_STYLE_END-->
<script>
    <!--
var active_lang='hdevelop';function switchVisibility(obj,active_lang,new_lang)
{var display_style='inline';
for(var i=0;i<obj.length;i++)
{if(obj.item(i).getAttribute('data-if')==new_lang)
{obj.item(i).style.display=display_style;}
if(obj.item(i).getAttribute('data-if')==active_lang)
{obj.item(i).style.display='none';}}
return;}
function toggleLanguage(new_lang,initial)
{if(active_lang!=new_lang)
{var lis=document.getElementsByTagName('li');for(var i=0;i<lis.length;i++)
{if(lis.item(i).id=='syn-'+new_lang)
{lis.item(i).className='active';}
else
{lis.item(i).className='inactive';}}
var divs=document.getElementsByTagName('div');var spans=document.getElementsByTagName('span');switchVisibility(divs,active_lang,new_lang);switchVisibility(spans,active_lang,new_lang);if(!initial)
{setCookie("halcon_reference_language",new_lang,null,null);}
active_lang=new_lang;}
return;}
function setCookie(name,value,domain,exp_offset,path,secure)
{localStorage.setItem(name,value);}
function getCookie(name)
{return localStorage.getItem(name);}
function initialize()
{var qs=location.href.split('?')[1];var qs_lang_raw=location.href.split('interface=')[1];var qs_lang;if(qs_lang_raw)
{qs_lang=qs_lang_raw.split('#')[0];}
var cookie_lang=getCookie("halcon_reference_language");var new_lang;if((qs_lang=="hdevelop")||(qs_lang=="dotnet")||(qs_lang=="python")||(qs_lang=="cpp")||(qs_lang=="c"))
{new_lang=qs_lang;setCookie("halcon_reference_language",new_lang,null,null);}
else if((cookie_lang=="hdevelop")||(cookie_lang=="dotnet")||(cookie_lang=="python")||(cookie_lang=="cpp")||(cookie_lang=="c"))
{new_lang=cookie_lang;}
else
{new_lang="hdevelop";}
toggleLanguage(new_lang,1);return;}
-->

  </script>
</head>
<body onload="initialize();">
<div class="breadcrumb">
<br class="inv"><a href="index.html">目录</a> / <a href="toc_matching.html">Matching</a> / <a href="toc_matching_componentbased.html">Component-Based</a><br class="inv">
</div>
<div class="body_main">
<div class="tabbar"><ul class="tabs">
<li id="syn-hdevelop" class="active"><a href="javascript:void(0);" onclick="toggleLanguage('hdevelop')" onfocus="blur()">HDevelop</a></li>
<li id="syn-dotnet" class="inactive"><a href="javascript:void(0);" onclick="toggleLanguage('dotnet')" onfocus="blur()">.NET</a></li>
<li id="syn-python" class="inactive"><a href="javascript:void(0);" onclick="toggleLanguage('python')" onfocus="blur()">Python</a></li>
<li id="syn-cpp" class="inactive"><a href="javascript:void(0);" onclick="toggleLanguage('cpp')" onfocus="blur()">C++</a></li>
<li id="syn-c" class="inactive"><a href="javascript:void(0);" onclick="toggleLanguage('c')" onfocus="blur()">C</a></li>
</ul></div>
<div class="indexlink">
<a href="index_classes.html"><span data-if="dotnet" style="display:none;">类别</span><span data-if="cpp" style="display:none;">类别</span></a><span data-if="dotnet" style="display:none;"> | </span><span data-if="cpp" style="display:none;"> | </span><a href="index_by_name.html">算子列表</a>
</div>
<!--OP_REF_HEADER_END-->
<h1 id="sec_name">
<span data-if="hdevelop" style="display:inline;">train_model_components</span><span data-if="c" style="display:none;">T_train_model_components</span><span data-if="cpp" style="display:none;">TrainModelComponents</span><span data-if="dotnet" style="display:none;">TrainModelComponents</span><span data-if="python" style="display:none;">train_model_components</span> (算子名称)</h1>
<h2>名称</h2>
<p><code><span data-if="hdevelop" style="display:inline;">train_model_components</span><span data-if="c" style="display:none;">T_train_model_components</span><span data-if="cpp" style="display:none;">TrainModelComponents</span><span data-if="dotnet" style="display:none;">TrainModelComponents</span><span data-if="python" style="display:none;">train_model_components</span></code> — Train components and relations for the component-based matching.</p>
<h2 id="sec_synopsis">参数签名</h2>
<div data-if="hdevelop" style="display:inline;">
<p>
<code><b>train_model_components</b>(<a href="#ModelImage"><i>ModelImage</i></a>, <a href="#InitialComponents"><i>InitialComponents</i></a>, <a href="#TrainingImages"><i>TrainingImages</i></a> : <a href="#ModelComponents"><i>ModelComponents</i></a> : <a href="#ContrastLow"><i>ContrastLow</i></a>, <a href="#ContrastHigh"><i>ContrastHigh</i></a>, <a href="#MinSize"><i>MinSize</i></a>, <a href="#MinScore"><i>MinScore</i></a>, <a href="#SearchRowTol"><i>SearchRowTol</i></a>, <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, <a href="#ClusterThreshold"><i>ClusterThreshold</i></a> : <a href="#ComponentTrainingID"><i>ComponentTrainingID</i></a>)</code></p>
</div>
<div data-if="c" style="display:none;">
<p>
<code>Herror <b>T_train_model_components</b>(const Hobject <a href="#ModelImage"><i>ModelImage</i></a>, const Hobject <a href="#InitialComponents"><i>InitialComponents</i></a>, const Hobject <a href="#TrainingImages"><i>TrainingImages</i></a>, Hobject* <a href="#ModelComponents"><i>ModelComponents</i></a>, const Htuple <a href="#ContrastLow"><i>ContrastLow</i></a>, const Htuple <a href="#ContrastHigh"><i>ContrastHigh</i></a>, const Htuple <a href="#MinSize"><i>MinSize</i></a>, const Htuple <a href="#MinScore"><i>MinScore</i></a>, const Htuple <a href="#SearchRowTol"><i>SearchRowTol</i></a>, const Htuple <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, const Htuple <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const Htuple <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const Htuple <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, const Htuple <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, const Htuple <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>, Htuple* <a href="#ComponentTrainingID"><i>ComponentTrainingID</i></a>)</code></p>
</div>
<div data-if="cpp" style="display:none;">
<p>
<code>void <b>TrainModelComponents</b>(const HObject&amp; <a href="#ModelImage"><i>ModelImage</i></a>, const HObject&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HObject&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, HObject* <a href="#ModelComponents"><i>ModelComponents</i></a>, const HTuple&amp; <a href="#ContrastLow"><i>ContrastLow</i></a>, const HTuple&amp; <a href="#ContrastHigh"><i>ContrastHigh</i></a>, const HTuple&amp; <a href="#MinSize"><i>MinSize</i></a>, const HTuple&amp; <a href="#MinScore"><i>MinScore</i></a>, const HTuple&amp; <a href="#SearchRowTol"><i>SearchRowTol</i></a>, const HTuple&amp; <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, const HTuple&amp; <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const HTuple&amp; <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const HTuple&amp; <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, const HTuple&amp; <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, const HTuple&amp; <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>, HTuple* <a href="#ComponentTrainingID"><i>ComponentTrainingID</i></a>)</code></p>
<p>
<code>void <a href="HComponentTraining.html">HComponentTraining</a>::<b>HComponentTraining</b>(const HImage&amp; <a href="#ModelImage"><i>ModelImage</i></a>, const HRegion&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HImage&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, HRegion* <a href="#ModelComponents"><i>ModelComponents</i></a>, const HTuple&amp; <a href="#ContrastLow"><i>ContrastLow</i></a>, const HTuple&amp; <a href="#ContrastHigh"><i>ContrastHigh</i></a>, const HTuple&amp; <a href="#MinSize"><i>MinSize</i></a>, const HTuple&amp; <a href="#MinScore"><i>MinScore</i></a>, const HTuple&amp; <a href="#SearchRowTol"><i>SearchRowTol</i></a>, const HTuple&amp; <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, const HTuple&amp; <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const HString&amp; <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const HString&amp; <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>)</code></p>
<p>
<code>void <a href="HComponentTraining.html">HComponentTraining</a>::<b>HComponentTraining</b>(const HImage&amp; <a href="#ModelImage"><i>ModelImage</i></a>, const HRegion&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HImage&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, HRegion* <a href="#ModelComponents"><i>ModelComponents</i></a>, Hlong <a href="#ContrastLow"><i>ContrastLow</i></a>, Hlong <a href="#ContrastHigh"><i>ContrastHigh</i></a>, Hlong <a href="#MinSize"><i>MinSize</i></a>, double <a href="#MinScore"><i>MinScore</i></a>, Hlong <a href="#SearchRowTol"><i>SearchRowTol</i></a>, Hlong <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, double <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const HString&amp; <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const HString&amp; <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>)</code></p>
<p>
<code>void <a href="HComponentTraining.html">HComponentTraining</a>::<b>HComponentTraining</b>(const HImage&amp; <a href="#ModelImage"><i>ModelImage</i></a>, const HRegion&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HImage&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, HRegion* <a href="#ModelComponents"><i>ModelComponents</i></a>, Hlong <a href="#ContrastLow"><i>ContrastLow</i></a>, Hlong <a href="#ContrastHigh"><i>ContrastHigh</i></a>, Hlong <a href="#MinSize"><i>MinSize</i></a>, double <a href="#MinScore"><i>MinScore</i></a>, Hlong <a href="#SearchRowTol"><i>SearchRowTol</i></a>, Hlong <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, double <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const char* <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const char* <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>)</code></p>
<p>
<code>void <a href="HComponentTraining.html">HComponentTraining</a>::<b>HComponentTraining</b>(const HImage&amp; <a href="#ModelImage"><i>ModelImage</i></a>, const HRegion&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HImage&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, HRegion* <a href="#ModelComponents"><i>ModelComponents</i></a>, Hlong <a href="#ContrastLow"><i>ContrastLow</i></a>, Hlong <a href="#ContrastHigh"><i>ContrastHigh</i></a>, Hlong <a href="#MinSize"><i>MinSize</i></a>, double <a href="#MinScore"><i>MinScore</i></a>, Hlong <a href="#SearchRowTol"><i>SearchRowTol</i></a>, Hlong <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, double <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const wchar_t* <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const wchar_t* <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>)  <span class="signnote">
            (
            Windows only)
          </span></code></p>
<p>
<code><a href="HRegion.html">HRegion</a> <a href="HComponentTraining.html">HComponentTraining</a>::<b>TrainModelComponents</b>(const HImage&amp; <a href="#ModelImage"><i>ModelImage</i></a>, const HRegion&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HImage&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, const HTuple&amp; <a href="#ContrastLow"><i>ContrastLow</i></a>, const HTuple&amp; <a href="#ContrastHigh"><i>ContrastHigh</i></a>, const HTuple&amp; <a href="#MinSize"><i>MinSize</i></a>, const HTuple&amp; <a href="#MinScore"><i>MinScore</i></a>, const HTuple&amp; <a href="#SearchRowTol"><i>SearchRowTol</i></a>, const HTuple&amp; <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, const HTuple&amp; <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const HString&amp; <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const HString&amp; <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>)</code></p>
<p>
<code><a href="HRegion.html">HRegion</a> <a href="HComponentTraining.html">HComponentTraining</a>::<b>TrainModelComponents</b>(const HImage&amp; <a href="#ModelImage"><i>ModelImage</i></a>, const HRegion&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HImage&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, Hlong <a href="#ContrastLow"><i>ContrastLow</i></a>, Hlong <a href="#ContrastHigh"><i>ContrastHigh</i></a>, Hlong <a href="#MinSize"><i>MinSize</i></a>, double <a href="#MinScore"><i>MinScore</i></a>, Hlong <a href="#SearchRowTol"><i>SearchRowTol</i></a>, Hlong <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, double <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const HString&amp; <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const HString&amp; <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>)</code></p>
<p>
<code><a href="HRegion.html">HRegion</a> <a href="HComponentTraining.html">HComponentTraining</a>::<b>TrainModelComponents</b>(const HImage&amp; <a href="#ModelImage"><i>ModelImage</i></a>, const HRegion&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HImage&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, Hlong <a href="#ContrastLow"><i>ContrastLow</i></a>, Hlong <a href="#ContrastHigh"><i>ContrastHigh</i></a>, Hlong <a href="#MinSize"><i>MinSize</i></a>, double <a href="#MinScore"><i>MinScore</i></a>, Hlong <a href="#SearchRowTol"><i>SearchRowTol</i></a>, Hlong <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, double <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const char* <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const char* <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>)</code></p>
<p>
<code><a href="HRegion.html">HRegion</a> <a href="HComponentTraining.html">HComponentTraining</a>::<b>TrainModelComponents</b>(const HImage&amp; <a href="#ModelImage"><i>ModelImage</i></a>, const HRegion&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HImage&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, Hlong <a href="#ContrastLow"><i>ContrastLow</i></a>, Hlong <a href="#ContrastHigh"><i>ContrastHigh</i></a>, Hlong <a href="#MinSize"><i>MinSize</i></a>, double <a href="#MinScore"><i>MinScore</i></a>, Hlong <a href="#SearchRowTol"><i>SearchRowTol</i></a>, Hlong <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, double <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const wchar_t* <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const wchar_t* <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>)  <span class="signnote">
            (
            Windows only)
          </span></code></p>
<p>
<code><a href="HRegion.html">HRegion</a> <a href="HImage.html">HImage</a>::<b>TrainModelComponents</b>(const HRegion&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HImage&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, const HTuple&amp; <a href="#ContrastLow"><i>ContrastLow</i></a>, const HTuple&amp; <a href="#ContrastHigh"><i>ContrastHigh</i></a>, const HTuple&amp; <a href="#MinSize"><i>MinSize</i></a>, const HTuple&amp; <a href="#MinScore"><i>MinScore</i></a>, const HTuple&amp; <a href="#SearchRowTol"><i>SearchRowTol</i></a>, const HTuple&amp; <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, const HTuple&amp; <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const HString&amp; <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const HString&amp; <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>, HComponentTraining* <a href="#ComponentTrainingID"><i>ComponentTrainingID</i></a>) const</code></p>
<p>
<code><a href="HRegion.html">HRegion</a> <a href="HImage.html">HImage</a>::<b>TrainModelComponents</b>(const HRegion&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HImage&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, Hlong <a href="#ContrastLow"><i>ContrastLow</i></a>, Hlong <a href="#ContrastHigh"><i>ContrastHigh</i></a>, Hlong <a href="#MinSize"><i>MinSize</i></a>, double <a href="#MinScore"><i>MinScore</i></a>, Hlong <a href="#SearchRowTol"><i>SearchRowTol</i></a>, Hlong <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, double <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const HString&amp; <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const HString&amp; <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>, HComponentTraining* <a href="#ComponentTrainingID"><i>ComponentTrainingID</i></a>) const</code></p>
<p>
<code><a href="HRegion.html">HRegion</a> <a href="HImage.html">HImage</a>::<b>TrainModelComponents</b>(const HRegion&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HImage&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, Hlong <a href="#ContrastLow"><i>ContrastLow</i></a>, Hlong <a href="#ContrastHigh"><i>ContrastHigh</i></a>, Hlong <a href="#MinSize"><i>MinSize</i></a>, double <a href="#MinScore"><i>MinScore</i></a>, Hlong <a href="#SearchRowTol"><i>SearchRowTol</i></a>, Hlong <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, double <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const char* <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const char* <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>, HComponentTraining* <a href="#ComponentTrainingID"><i>ComponentTrainingID</i></a>) const</code></p>
<p>
<code><a href="HRegion.html">HRegion</a> <a href="HImage.html">HImage</a>::<b>TrainModelComponents</b>(const HRegion&amp; <a href="#InitialComponents"><i>InitialComponents</i></a>, const HImage&amp; <a href="#TrainingImages"><i>TrainingImages</i></a>, Hlong <a href="#ContrastLow"><i>ContrastLow</i></a>, Hlong <a href="#ContrastHigh"><i>ContrastHigh</i></a>, Hlong <a href="#MinSize"><i>MinSize</i></a>, double <a href="#MinScore"><i>MinScore</i></a>, Hlong <a href="#SearchRowTol"><i>SearchRowTol</i></a>, Hlong <a href="#SearchColumnTol"><i>SearchColumnTol</i></a>, double <a href="#SearchAngleTol"><i>SearchAngleTol</i></a>, const wchar_t* <a href="#TrainingEmphasis"><i>TrainingEmphasis</i></a>, const wchar_t* <a href="#AmbiguityCriterion"><i>AmbiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>MaxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>ClusterThreshold</i></a>, HComponentTraining* <a href="#ComponentTrainingID"><i>ComponentTrainingID</i></a>) const  <span class="signnote">
            (
            Windows only)
          </span></code></p>
</div>
<div data-if="com" style="display:none;"></div>
<div data-if="dotnet" style="display:none;">
<p>
<code>static void <a href="HOperatorSet.html">HOperatorSet</a>.<b>TrainModelComponents</b>(<a href="HObject.html">HObject</a> <a href="#ModelImage"><i>modelImage</i></a>, <a href="HObject.html">HObject</a> <a href="#InitialComponents"><i>initialComponents</i></a>, <a href="HObject.html">HObject</a> <a href="#TrainingImages"><i>trainingImages</i></a>, out <a href="HObject.html">HObject</a> <a href="#ModelComponents"><i>modelComponents</i></a>, <a href="HTuple.html">HTuple</a> <a href="#ContrastLow"><i>contrastLow</i></a>, <a href="HTuple.html">HTuple</a> <a href="#ContrastHigh"><i>contrastHigh</i></a>, <a href="HTuple.html">HTuple</a> <a href="#MinSize"><i>minSize</i></a>, <a href="HTuple.html">HTuple</a> <a href="#MinScore"><i>minScore</i></a>, <a href="HTuple.html">HTuple</a> <a href="#SearchRowTol"><i>searchRowTol</i></a>, <a href="HTuple.html">HTuple</a> <a href="#SearchColumnTol"><i>searchColumnTol</i></a>, <a href="HTuple.html">HTuple</a> <a href="#SearchAngleTol"><i>searchAngleTol</i></a>, <a href="HTuple.html">HTuple</a> <a href="#TrainingEmphasis"><i>trainingEmphasis</i></a>, <a href="HTuple.html">HTuple</a> <a href="#AmbiguityCriterion"><i>ambiguityCriterion</i></a>, <a href="HTuple.html">HTuple</a> <a href="#MaxContourOverlap"><i>maxContourOverlap</i></a>, <a href="HTuple.html">HTuple</a> <a href="#ClusterThreshold"><i>clusterThreshold</i></a>, out <a href="HTuple.html">HTuple</a> <a href="#ComponentTrainingID"><i>componentTrainingID</i></a>)</code></p>
<p>
<code>public <a href="HComponentTraining.html">HComponentTraining</a>(<a href="HImage.html">HImage</a> <a href="#ModelImage"><i>modelImage</i></a>, <a href="HRegion.html">HRegion</a> <a href="#InitialComponents"><i>initialComponents</i></a>, <a href="HImage.html">HImage</a> <a href="#TrainingImages"><i>trainingImages</i></a>, out <a href="HRegion.html">HRegion</a> <a href="#ModelComponents"><i>modelComponents</i></a>, <a href="HTuple.html">HTuple</a> <a href="#ContrastLow"><i>contrastLow</i></a>, <a href="HTuple.html">HTuple</a> <a href="#ContrastHigh"><i>contrastHigh</i></a>, <a href="HTuple.html">HTuple</a> <a href="#MinSize"><i>minSize</i></a>, <a href="HTuple.html">HTuple</a> <a href="#MinScore"><i>minScore</i></a>, <a href="HTuple.html">HTuple</a> <a href="#SearchRowTol"><i>searchRowTol</i></a>, <a href="HTuple.html">HTuple</a> <a href="#SearchColumnTol"><i>searchColumnTol</i></a>, <a href="HTuple.html">HTuple</a> <a href="#SearchAngleTol"><i>searchAngleTol</i></a>, string <a href="#TrainingEmphasis"><i>trainingEmphasis</i></a>, string <a href="#AmbiguityCriterion"><i>ambiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>maxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>clusterThreshold</i></a>)</code></p>
<p>
<code>public <a href="HComponentTraining.html">HComponentTraining</a>(<a href="HImage.html">HImage</a> <a href="#ModelImage"><i>modelImage</i></a>, <a href="HRegion.html">HRegion</a> <a href="#InitialComponents"><i>initialComponents</i></a>, <a href="HImage.html">HImage</a> <a href="#TrainingImages"><i>trainingImages</i></a>, out <a href="HRegion.html">HRegion</a> <a href="#ModelComponents"><i>modelComponents</i></a>, int <a href="#ContrastLow"><i>contrastLow</i></a>, int <a href="#ContrastHigh"><i>contrastHigh</i></a>, int <a href="#MinSize"><i>minSize</i></a>, double <a href="#MinScore"><i>minScore</i></a>, int <a href="#SearchRowTol"><i>searchRowTol</i></a>, int <a href="#SearchColumnTol"><i>searchColumnTol</i></a>, double <a href="#SearchAngleTol"><i>searchAngleTol</i></a>, string <a href="#TrainingEmphasis"><i>trainingEmphasis</i></a>, string <a href="#AmbiguityCriterion"><i>ambiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>maxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>clusterThreshold</i></a>)</code></p>
<p>
<code><a href="HRegion.html">HRegion</a> <a href="HComponentTraining.html">HComponentTraining</a>.<b>TrainModelComponents</b>(<a href="HImage.html">HImage</a> <a href="#ModelImage"><i>modelImage</i></a>, <a href="HRegion.html">HRegion</a> <a href="#InitialComponents"><i>initialComponents</i></a>, <a href="HImage.html">HImage</a> <a href="#TrainingImages"><i>trainingImages</i></a>, <a href="HTuple.html">HTuple</a> <a href="#ContrastLow"><i>contrastLow</i></a>, <a href="HTuple.html">HTuple</a> <a href="#ContrastHigh"><i>contrastHigh</i></a>, <a href="HTuple.html">HTuple</a> <a href="#MinSize"><i>minSize</i></a>, <a href="HTuple.html">HTuple</a> <a href="#MinScore"><i>minScore</i></a>, <a href="HTuple.html">HTuple</a> <a href="#SearchRowTol"><i>searchRowTol</i></a>, <a href="HTuple.html">HTuple</a> <a href="#SearchColumnTol"><i>searchColumnTol</i></a>, <a href="HTuple.html">HTuple</a> <a href="#SearchAngleTol"><i>searchAngleTol</i></a>, string <a href="#TrainingEmphasis"><i>trainingEmphasis</i></a>, string <a href="#AmbiguityCriterion"><i>ambiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>maxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>clusterThreshold</i></a>)</code></p>
<p>
<code><a href="HRegion.html">HRegion</a> <a href="HComponentTraining.html">HComponentTraining</a>.<b>TrainModelComponents</b>(<a href="HImage.html">HImage</a> <a href="#ModelImage"><i>modelImage</i></a>, <a href="HRegion.html">HRegion</a> <a href="#InitialComponents"><i>initialComponents</i></a>, <a href="HImage.html">HImage</a> <a href="#TrainingImages"><i>trainingImages</i></a>, int <a href="#ContrastLow"><i>contrastLow</i></a>, int <a href="#ContrastHigh"><i>contrastHigh</i></a>, int <a href="#MinSize"><i>minSize</i></a>, double <a href="#MinScore"><i>minScore</i></a>, int <a href="#SearchRowTol"><i>searchRowTol</i></a>, int <a href="#SearchColumnTol"><i>searchColumnTol</i></a>, double <a href="#SearchAngleTol"><i>searchAngleTol</i></a>, string <a href="#TrainingEmphasis"><i>trainingEmphasis</i></a>, string <a href="#AmbiguityCriterion"><i>ambiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>maxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>clusterThreshold</i></a>)</code></p>
<p>
<code><a href="HRegion.html">HRegion</a> <a href="HImage.html">HImage</a>.<b>TrainModelComponents</b>(<a href="HRegion.html">HRegion</a> <a href="#InitialComponents"><i>initialComponents</i></a>, <a href="HImage.html">HImage</a> <a href="#TrainingImages"><i>trainingImages</i></a>, <a href="HTuple.html">HTuple</a> <a href="#ContrastLow"><i>contrastLow</i></a>, <a href="HTuple.html">HTuple</a> <a href="#ContrastHigh"><i>contrastHigh</i></a>, <a href="HTuple.html">HTuple</a> <a href="#MinSize"><i>minSize</i></a>, <a href="HTuple.html">HTuple</a> <a href="#MinScore"><i>minScore</i></a>, <a href="HTuple.html">HTuple</a> <a href="#SearchRowTol"><i>searchRowTol</i></a>, <a href="HTuple.html">HTuple</a> <a href="#SearchColumnTol"><i>searchColumnTol</i></a>, <a href="HTuple.html">HTuple</a> <a href="#SearchAngleTol"><i>searchAngleTol</i></a>, string <a href="#TrainingEmphasis"><i>trainingEmphasis</i></a>, string <a href="#AmbiguityCriterion"><i>ambiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>maxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>clusterThreshold</i></a>, out <a href="HComponentTraining.html">HComponentTraining</a> <a href="#ComponentTrainingID"><i>componentTrainingID</i></a>)</code></p>
<p>
<code><a href="HRegion.html">HRegion</a> <a href="HImage.html">HImage</a>.<b>TrainModelComponents</b>(<a href="HRegion.html">HRegion</a> <a href="#InitialComponents"><i>initialComponents</i></a>, <a href="HImage.html">HImage</a> <a href="#TrainingImages"><i>trainingImages</i></a>, int <a href="#ContrastLow"><i>contrastLow</i></a>, int <a href="#ContrastHigh"><i>contrastHigh</i></a>, int <a href="#MinSize"><i>minSize</i></a>, double <a href="#MinScore"><i>minScore</i></a>, int <a href="#SearchRowTol"><i>searchRowTol</i></a>, int <a href="#SearchColumnTol"><i>searchColumnTol</i></a>, double <a href="#SearchAngleTol"><i>searchAngleTol</i></a>, string <a href="#TrainingEmphasis"><i>trainingEmphasis</i></a>, string <a href="#AmbiguityCriterion"><i>ambiguityCriterion</i></a>, double <a href="#MaxContourOverlap"><i>maxContourOverlap</i></a>, double <a href="#ClusterThreshold"><i>clusterThreshold</i></a>, out <a href="HComponentTraining.html">HComponentTraining</a> <a href="#ComponentTrainingID"><i>componentTrainingID</i></a>)</code></p>
</div>
<div data-if="python" style="display:none;">
<p>
<code>def <b>train_model_components</b>(<a href="#ModelImage"><i>model_image</i></a>: HObject, <a href="#InitialComponents"><i>initial_components</i></a>: HObject, <a href="#TrainingImages"><i>training_images</i></a>: HObject, <a href="#ContrastLow"><i>contrast_low</i></a>: MaybeSequence[Union[int, str]], <a href="#ContrastHigh"><i>contrast_high</i></a>: MaybeSequence[Union[int, str]], <a href="#MinSize"><i>min_size</i></a>: MaybeSequence[Union[int, str]], <a href="#MinScore"><i>min_score</i></a>: MaybeSequence[float], <a href="#SearchRowTol"><i>search_row_tol</i></a>: MaybeSequence[int], <a href="#SearchColumnTol"><i>search_column_tol</i></a>: MaybeSequence[int], <a href="#SearchAngleTol"><i>search_angle_tol</i></a>: MaybeSequence[float], <a href="#TrainingEmphasis"><i>training_emphasis</i></a>: str, <a href="#AmbiguityCriterion"><i>ambiguity_criterion</i></a>: str, <a href="#MaxContourOverlap"><i>max_contour_overlap</i></a>: float, <a href="#ClusterThreshold"><i>cluster_threshold</i></a>: float) -&gt; Tuple[HObject, HHandle]</code></p>
</div>
<h2 id="sec_description">描述</h2>
<p><code><span data-if="hdevelop" style="display:inline">train_model_components</span><span data-if="c" style="display:none">train_model_components</span><span data-if="cpp" style="display:none">TrainModelComponents</span><span data-if="com" style="display:none">TrainModelComponents</span><span data-if="dotnet" style="display:none">TrainModelComponents</span><span data-if="python" style="display:none">train_model_components</span></code> extracts the final (rigid) model
components and trains their mutual relations, i.e., their relative
movements, on the basis of the initial components by considering
several training images. The result of the training is returned in
the handle <a href="#ComponentTrainingID"><i><code><span data-if="hdevelop" style="display:inline">ComponentTrainingID</span><span data-if="c" style="display:none">ComponentTrainingID</span><span data-if="cpp" style="display:none">ComponentTrainingID</span><span data-if="com" style="display:none">ComponentTrainingID</span><span data-if="dotnet" style="display:none">componentTrainingID</span><span data-if="python" style="display:none">component_training_id</span></code></i></a>. The training result can be
subsequently used to create the actual component model using
<a href="create_trained_component_model.html"><code><span data-if="hdevelop" style="display:inline">create_trained_component_model</span><span data-if="c" style="display:none">create_trained_component_model</span><span data-if="cpp" style="display:none">CreateTrainedComponentModel</span><span data-if="com" style="display:none">CreateTrainedComponentModel</span><span data-if="dotnet" style="display:none">CreateTrainedComponentModel</span><span data-if="python" style="display:none">create_trained_component_model</span></code></a>.
</p>
<p><code><span data-if="hdevelop" style="display:inline">train_model_components</span><span data-if="c" style="display:none">train_model_components</span><span data-if="cpp" style="display:none">TrainModelComponents</span><span data-if="com" style="display:none">TrainModelComponents</span><span data-if="dotnet" style="display:none">TrainModelComponents</span><span data-if="python" style="display:none">train_model_components</span></code> should be used in cases where the
relations of the components are not known and should be trained
automatically. In contrast, if the relations are known no training
needs to be performed with <code><span data-if="hdevelop" style="display:inline">train_model_components</span><span data-if="c" style="display:none">train_model_components</span><span data-if="cpp" style="display:none">TrainModelComponents</span><span data-if="com" style="display:none">TrainModelComponents</span><span data-if="dotnet" style="display:none">TrainModelComponents</span><span data-if="python" style="display:none">train_model_components</span></code>. Instead,
the component model can be directly created with
<a href="create_component_model.html"><code><span data-if="hdevelop" style="display:inline">create_component_model</span><span data-if="c" style="display:none">create_component_model</span><span data-if="cpp" style="display:none">CreateComponentModel</span><span data-if="com" style="display:none">CreateComponentModel</span><span data-if="dotnet" style="display:none">CreateComponentModel</span><span data-if="python" style="display:none">create_component_model</span></code></a>.
</p>
<p>If the initial components have been automatically created by using
<a href="gen_initial_components.html"><code><span data-if="hdevelop" style="display:inline">gen_initial_components</span><span data-if="c" style="display:none">gen_initial_components</span><span data-if="cpp" style="display:none">GenInitialComponents</span><span data-if="com" style="display:none">GenInitialComponents</span><span data-if="dotnet" style="display:none">GenInitialComponents</span><span data-if="python" style="display:none">gen_initial_components</span></code></a>, <a href="#InitialComponents"><i><code><span data-if="hdevelop" style="display:inline">InitialComponents</span><span data-if="c" style="display:none">InitialComponents</span><span data-if="cpp" style="display:none">InitialComponents</span><span data-if="com" style="display:none">InitialComponents</span><span data-if="dotnet" style="display:none">initialComponents</span><span data-if="python" style="display:none">initial_components</span></code></i></a> contains
the contour regions of the initial components. In contrast, if the
initial components should be defined by the user, they can be
directly passed in <a href="#InitialComponents"><i><code><span data-if="hdevelop" style="display:inline">InitialComponents</span><span data-if="c" style="display:none">InitialComponents</span><span data-if="cpp" style="display:none">InitialComponents</span><span data-if="com" style="display:none">InitialComponents</span><span data-if="dotnet" style="display:none">initialComponents</span><span data-if="python" style="display:none">initial_components</span></code></i></a>. However, instead of
the contour regions for each initial component, its enclosing region
must be passed in the tuple. The (contour) regions refer to the
model image <a href="#ModelImage"><i><code><span data-if="hdevelop" style="display:inline">ModelImage</span><span data-if="c" style="display:none">ModelImage</span><span data-if="cpp" style="display:none">ModelImage</span><span data-if="com" style="display:none">ModelImage</span><span data-if="dotnet" style="display:none">modelImage</span><span data-if="python" style="display:none">model_image</span></code></i></a>. If the initial components have been
obtained using <a href="gen_initial_components.html"><code><span data-if="hdevelop" style="display:inline">gen_initial_components</span><span data-if="c" style="display:none">gen_initial_components</span><span data-if="cpp" style="display:none">GenInitialComponents</span><span data-if="com" style="display:none">GenInitialComponents</span><span data-if="dotnet" style="display:none">GenInitialComponents</span><span data-if="python" style="display:none">gen_initial_components</span></code></a>, the model image
should be the same as in <a href="gen_initial_components.html"><code><span data-if="hdevelop" style="display:inline">gen_initial_components</span><span data-if="c" style="display:none">gen_initial_components</span><span data-if="cpp" style="display:none">GenInitialComponents</span><span data-if="com" style="display:none">GenInitialComponents</span><span data-if="dotnet" style="display:none">GenInitialComponents</span><span data-if="python" style="display:none">gen_initial_components</span></code></a>.  Please
note that each initial component is part of at most one rigid model
component. This is because during the training initial components
can be merged into rigid model components if required (see
below). However, they cannot be split and distributed to several
rigid model components.
</p>
<p><code><span data-if="hdevelop" style="display:inline">train_model_components</span><span data-if="c" style="display:none">train_model_components</span><span data-if="cpp" style="display:none">TrainModelComponents</span><span data-if="com" style="display:none">TrainModelComponents</span><span data-if="dotnet" style="display:none">TrainModelComponents</span><span data-if="python" style="display:none">train_model_components</span></code> uses the following approach to
perform the training: In the first step, the initial components are
searched in all training images. In some cases, one initial
component may be found in an training image more than once. Thus, in
the second step, the resulting ambiguities are solved, i.e., the
most probable pose of each initial component is found. Consequently,
after solving the ambiguities, in all training images at most one
pose of each initial component is available. In the next step the
poses are analyzed and those initial components that do not show any
relative movement are clustered to the final rigid model
components. Finally, in the last step the relations between the
model components are computed by analyzing their relative poses over
the sequence of training images. The parameters that are associated
with the mentioned steps are explained in the following.
</p>
<p>The training is performed based on several training images, which
are passed in <a href="#TrainingImages"><i><code><span data-if="hdevelop" style="display:inline">TrainingImages</span><span data-if="c" style="display:none">TrainingImages</span><span data-if="cpp" style="display:none">TrainingImages</span><span data-if="com" style="display:none">TrainingImages</span><span data-if="dotnet" style="display:none">trainingImages</span><span data-if="python" style="display:none">training_images</span></code></i></a>. Each training image must show
at most one instance of the compound object and should contain the
full range of allowed relative movements of the model components.
If, for example, the component model of an on/off switch should be
trained, one training image that shows the switch turned off is
sufficient if the switch in the model image is turned on, or vice
versa.
</p>
<p>The principle of the training is to find the initial components in
all training images and to analyze their poses. For this, for each
initial component a shape model is created (see
<a href="create_shape_model.html"><code><span data-if="hdevelop" style="display:inline">create_shape_model</span><span data-if="c" style="display:none">create_shape_model</span><span data-if="cpp" style="display:none">CreateShapeModel</span><span data-if="com" style="display:none">CreateShapeModel</span><span data-if="dotnet" style="display:none">CreateShapeModel</span><span data-if="python" style="display:none">create_shape_model</span></code></a>), which is then used to determine the
poses (position and orientation) of the initial components in the
training images (see <a href="find_shape_model.html"><code><span data-if="hdevelop" style="display:inline">find_shape_model</span><span data-if="c" style="display:none">find_shape_model</span><span data-if="cpp" style="display:none">FindShapeModel</span><span data-if="com" style="display:none">FindShapeModel</span><span data-if="dotnet" style="display:none">FindShapeModel</span><span data-if="python" style="display:none">find_shape_model</span></code></a>). Depending on the
mode that is set by using
<a href="set_system.html"><code><span data-if="hdevelop" style="display:inline">set_system('pregenerate_shape_models',...)</span><span data-if="c" style="display:none">set_system("pregenerate_shape_models",...)</span><span data-if="cpp" style="display:none">SetSystem("pregenerate_shape_models",...)</span><span data-if="com" style="display:none">SetSystem("pregenerate_shape_models",...)</span><span data-if="dotnet" style="display:none">SetSystem("pregenerate_shape_models",...)</span><span data-if="python" style="display:none">set_system("pregenerate_shape_models",...)</span></code></a>, the shape model
is either pregenerated completely or computed online during the
search.  The mode influences the computation time as well as the
robustness of the training.  Furthermore, it should be noted that if
single-channel image are used in <a href="#ModelImage"><i><code><span data-if="hdevelop" style="display:inline">ModelImage</span><span data-if="c" style="display:none">ModelImage</span><span data-if="cpp" style="display:none">ModelImage</span><span data-if="com" style="display:none">ModelImage</span><span data-if="dotnet" style="display:none">modelImage</span><span data-if="python" style="display:none">model_image</span></code></i></a> as well as in
<a href="#TrainingImages"><i><code><span data-if="hdevelop" style="display:inline">TrainingImages</span><span data-if="c" style="display:none">TrainingImages</span><span data-if="cpp" style="display:none">TrainingImages</span><span data-if="com" style="display:none">TrainingImages</span><span data-if="dotnet" style="display:none">trainingImages</span><span data-if="python" style="display:none">training_images</span></code></i></a> the metric <i><span data-if="hdevelop" style="display:inline">'use_polarity'</span><span data-if="c" style="display:none">"use_polarity"</span><span data-if="cpp" style="display:none">"use_polarity"</span><span data-if="com" style="display:none">"use_polarity"</span><span data-if="dotnet" style="display:none">"use_polarity"</span><span data-if="python" style="display:none">"use_polarity"</span></i> is used
internally for <a href="create_shape_model.html"><code><span data-if="hdevelop" style="display:inline">create_shape_model</span><span data-if="c" style="display:none">create_shape_model</span><span data-if="cpp" style="display:none">CreateShapeModel</span><span data-if="com" style="display:none">CreateShapeModel</span><span data-if="dotnet" style="display:none">CreateShapeModel</span><span data-if="python" style="display:none">create_shape_model</span></code></a>, while if multichannel
images are used in either <a href="#ModelImage"><i><code><span data-if="hdevelop" style="display:inline">ModelImage</span><span data-if="c" style="display:none">ModelImage</span><span data-if="cpp" style="display:none">ModelImage</span><span data-if="com" style="display:none">ModelImage</span><span data-if="dotnet" style="display:none">modelImage</span><span data-if="python" style="display:none">model_image</span></code></i></a> or
<a href="#TrainingImages"><i><code><span data-if="hdevelop" style="display:inline">TrainingImages</span><span data-if="c" style="display:none">TrainingImages</span><span data-if="cpp" style="display:none">TrainingImages</span><span data-if="com" style="display:none">TrainingImages</span><span data-if="dotnet" style="display:none">trainingImages</span><span data-if="python" style="display:none">training_images</span></code></i></a> the metric <i><span data-if="hdevelop" style="display:inline">'ignore_color_polarity'</span><span data-if="c" style="display:none">"ignore_color_polarity"</span><span data-if="cpp" style="display:none">"ignore_color_polarity"</span><span data-if="com" style="display:none">"ignore_color_polarity"</span><span data-if="dotnet" style="display:none">"ignore_color_polarity"</span><span data-if="python" style="display:none">"ignore_color_polarity"</span></i>
is used.  Finally, it should be noted that while the number of
channels in <a href="#ModelImage"><i><code><span data-if="hdevelop" style="display:inline">ModelImage</span><span data-if="c" style="display:none">ModelImage</span><span data-if="cpp" style="display:none">ModelImage</span><span data-if="com" style="display:none">ModelImage</span><span data-if="dotnet" style="display:none">modelImage</span><span data-if="python" style="display:none">model_image</span></code></i></a> and <a href="#TrainingImages"><i><code><span data-if="hdevelop" style="display:inline">TrainingImages</span><span data-if="c" style="display:none">TrainingImages</span><span data-if="cpp" style="display:none">TrainingImages</span><span data-if="com" style="display:none">TrainingImages</span><span data-if="dotnet" style="display:none">trainingImages</span><span data-if="python" style="display:none">training_images</span></code></i></a> may be
different, e.g., to facilitate model generation from synthetically
generated images, the number of channels in all the images in
<a href="#TrainingImages"><i><code><span data-if="hdevelop" style="display:inline">TrainingImages</span><span data-if="c" style="display:none">TrainingImages</span><span data-if="cpp" style="display:none">TrainingImages</span><span data-if="com" style="display:none">TrainingImages</span><span data-if="dotnet" style="display:none">trainingImages</span><span data-if="python" style="display:none">training_images</span></code></i></a> must be identical.  For further details see
<a href="create_shape_model.html"><code><span data-if="hdevelop" style="display:inline">create_shape_model</span><span data-if="c" style="display:none">create_shape_model</span><span data-if="cpp" style="display:none">CreateShapeModel</span><span data-if="com" style="display:none">CreateShapeModel</span><span data-if="dotnet" style="display:none">CreateShapeModel</span><span data-if="python" style="display:none">create_shape_model</span></code></a>. The creation of the shape models can be
influenced by choosing appropriate values for the parameters
<a href="#ContrastLow"><i><code><span data-if="hdevelop" style="display:inline">ContrastLow</span><span data-if="c" style="display:none">ContrastLow</span><span data-if="cpp" style="display:none">ContrastLow</span><span data-if="com" style="display:none">ContrastLow</span><span data-if="dotnet" style="display:none">contrastLow</span><span data-if="python" style="display:none">contrast_low</span></code></i></a>, <a href="#ContrastHigh"><i><code><span data-if="hdevelop" style="display:inline">ContrastHigh</span><span data-if="c" style="display:none">ContrastHigh</span><span data-if="cpp" style="display:none">ContrastHigh</span><span data-if="com" style="display:none">ContrastHigh</span><span data-if="dotnet" style="display:none">contrastHigh</span><span data-if="python" style="display:none">contrast_high</span></code></i></a>, and
<a href="#MinSize"><i><code><span data-if="hdevelop" style="display:inline">MinSize</span><span data-if="c" style="display:none">MinSize</span><span data-if="cpp" style="display:none">MinSize</span><span data-if="com" style="display:none">MinSize</span><span data-if="dotnet" style="display:none">minSize</span><span data-if="python" style="display:none">min_size</span></code></i></a>. These parameters have the same meaning as in
<a href="gen_initial_components.html"><code><span data-if="hdevelop" style="display:inline">gen_initial_components</span><span data-if="c" style="display:none">gen_initial_components</span><span data-if="cpp" style="display:none">GenInitialComponents</span><span data-if="com" style="display:none">GenInitialComponents</span><span data-if="dotnet" style="display:none">GenInitialComponents</span><span data-if="python" style="display:none">gen_initial_components</span></code></a> and can be automatically determined
by passing <i><span data-if="hdevelop" style="display:inline">'auto'</span><span data-if="c" style="display:none">"auto"</span><span data-if="cpp" style="display:none">"auto"</span><span data-if="com" style="display:none">"auto"</span><span data-if="dotnet" style="display:none">"auto"</span><span data-if="python" style="display:none">"auto"</span></i>: If both hysteresis threshold should be
automatically determined, both <a href="#ContrastLow"><i><code><span data-if="hdevelop" style="display:inline">ContrastLow</span><span data-if="c" style="display:none">ContrastLow</span><span data-if="cpp" style="display:none">ContrastLow</span><span data-if="com" style="display:none">ContrastLow</span><span data-if="dotnet" style="display:none">contrastLow</span><span data-if="python" style="display:none">contrast_low</span></code></i></a> and
<a href="#ContrastHigh"><i><code><span data-if="hdevelop" style="display:inline">ContrastHigh</span><span data-if="c" style="display:none">ContrastHigh</span><span data-if="cpp" style="display:none">ContrastHigh</span><span data-if="com" style="display:none">ContrastHigh</span><span data-if="dotnet" style="display:none">contrastHigh</span><span data-if="python" style="display:none">contrast_high</span></code></i></a> must be set to <i><span data-if="hdevelop" style="display:inline">'auto'</span><span data-if="c" style="display:none">"auto"</span><span data-if="cpp" style="display:none">"auto"</span><span data-if="com" style="display:none">"auto"</span><span data-if="dotnet" style="display:none">"auto"</span><span data-if="python" style="display:none">"auto"</span></i>. In contrast,
if only one threshold value should be determined,
<a href="#ContrastLow"><i><code><span data-if="hdevelop" style="display:inline">ContrastLow</span><span data-if="c" style="display:none">ContrastLow</span><span data-if="cpp" style="display:none">ContrastLow</span><span data-if="com" style="display:none">ContrastLow</span><span data-if="dotnet" style="display:none">contrastLow</span><span data-if="python" style="display:none">contrast_low</span></code></i></a> must be set to <i><span data-if="hdevelop" style="display:inline">'auto'</span><span data-if="c" style="display:none">"auto"</span><span data-if="cpp" style="display:none">"auto"</span><span data-if="com" style="display:none">"auto"</span><span data-if="dotnet" style="display:none">"auto"</span><span data-if="python" style="display:none">"auto"</span></i> while
<a href="#ContrastHigh"><i><code><span data-if="hdevelop" style="display:inline">ContrastHigh</span><span data-if="c" style="display:none">ContrastHigh</span><span data-if="cpp" style="display:none">ContrastHigh</span><span data-if="com" style="display:none">ContrastHigh</span><span data-if="dotnet" style="display:none">contrastHigh</span><span data-if="python" style="display:none">contrast_high</span></code></i></a> must be set to an arbitrary value different
from <i><span data-if="hdevelop" style="display:inline">'auto'</span><span data-if="c" style="display:none">"auto"</span><span data-if="cpp" style="display:none">"auto"</span><span data-if="com" style="display:none">"auto"</span><span data-if="dotnet" style="display:none">"auto"</span><span data-if="python" style="display:none">"auto"</span></i>.  If the initial components have been
automatically created by <a href="gen_initial_components.html"><code><span data-if="hdevelop" style="display:inline">gen_initial_components</span><span data-if="c" style="display:none">gen_initial_components</span><span data-if="cpp" style="display:none">GenInitialComponents</span><span data-if="com" style="display:none">GenInitialComponents</span><span data-if="dotnet" style="display:none">GenInitialComponents</span><span data-if="python" style="display:none">gen_initial_components</span></code></a>, the
parameters <a href="#ContrastLow"><i><code><span data-if="hdevelop" style="display:inline">ContrastLow</span><span data-if="c" style="display:none">ContrastLow</span><span data-if="cpp" style="display:none">ContrastLow</span><span data-if="com" style="display:none">ContrastLow</span><span data-if="dotnet" style="display:none">contrastLow</span><span data-if="python" style="display:none">contrast_low</span></code></i></a>, <a href="#ContrastHigh"><i><code><span data-if="hdevelop" style="display:inline">ContrastHigh</span><span data-if="c" style="display:none">ContrastHigh</span><span data-if="cpp" style="display:none">ContrastHigh</span><span data-if="com" style="display:none">ContrastHigh</span><span data-if="dotnet" style="display:none">contrastHigh</span><span data-if="python" style="display:none">contrast_high</span></code></i></a>, and
<a href="#MinSize"><i><code><span data-if="hdevelop" style="display:inline">MinSize</span><span data-if="c" style="display:none">MinSize</span><span data-if="cpp" style="display:none">MinSize</span><span data-if="com" style="display:none">MinSize</span><span data-if="dotnet" style="display:none">minSize</span><span data-if="python" style="display:none">min_size</span></code></i></a> should be set to the same values as in
<a href="gen_initial_components.html"><code><span data-if="hdevelop" style="display:inline">gen_initial_components</span><span data-if="c" style="display:none">gen_initial_components</span><span data-if="cpp" style="display:none">GenInitialComponents</span><span data-if="com" style="display:none">GenInitialComponents</span><span data-if="dotnet" style="display:none">GenInitialComponents</span><span data-if="python" style="display:none">gen_initial_components</span></code></a>.
</p>
<p>To influence the search for the initial components, the parameters
<a href="#MinScore"><i><code><span data-if="hdevelop" style="display:inline">MinScore</span><span data-if="c" style="display:none">MinScore</span><span data-if="cpp" style="display:none">MinScore</span><span data-if="com" style="display:none">MinScore</span><span data-if="dotnet" style="display:none">minScore</span><span data-if="python" style="display:none">min_score</span></code></i></a>, <a href="#SearchRowTol"><i><code><span data-if="hdevelop" style="display:inline">SearchRowTol</span><span data-if="c" style="display:none">SearchRowTol</span><span data-if="cpp" style="display:none">SearchRowTol</span><span data-if="com" style="display:none">SearchRowTol</span><span data-if="dotnet" style="display:none">searchRowTol</span><span data-if="python" style="display:none">search_row_tol</span></code></i></a>, <a href="#SearchColumnTol"><i><code><span data-if="hdevelop" style="display:inline">SearchColumnTol</span><span data-if="c" style="display:none">SearchColumnTol</span><span data-if="cpp" style="display:none">SearchColumnTol</span><span data-if="com" style="display:none">SearchColumnTol</span><span data-if="dotnet" style="display:none">searchColumnTol</span><span data-if="python" style="display:none">search_column_tol</span></code></i></a>,
<a href="#SearchAngleTol"><i><code><span data-if="hdevelop" style="display:inline">SearchAngleTol</span><span data-if="c" style="display:none">SearchAngleTol</span><span data-if="cpp" style="display:none">SearchAngleTol</span><span data-if="com" style="display:none">SearchAngleTol</span><span data-if="dotnet" style="display:none">searchAngleTol</span><span data-if="python" style="display:none">search_angle_tol</span></code></i></a>, and <a href="#TrainingEmphasis"><i><code><span data-if="hdevelop" style="display:inline">TrainingEmphasis</span><span data-if="c" style="display:none">TrainingEmphasis</span><span data-if="cpp" style="display:none">TrainingEmphasis</span><span data-if="com" style="display:none">TrainingEmphasis</span><span data-if="dotnet" style="display:none">trainingEmphasis</span><span data-if="python" style="display:none">training_emphasis</span></code></i></a> can be set.
The parameter <a href="#MinScore"><i><code><span data-if="hdevelop" style="display:inline">MinScore</span><span data-if="c" style="display:none">MinScore</span><span data-if="cpp" style="display:none">MinScore</span><span data-if="com" style="display:none">MinScore</span><span data-if="dotnet" style="display:none">minScore</span><span data-if="python" style="display:none">min_score</span></code></i></a> determines what score a potential
match must at least have to be regarded as an instance of the
initial component in the training image.  The larger
<a href="#MinScore"><i><code><span data-if="hdevelop" style="display:inline">MinScore</span><span data-if="c" style="display:none">MinScore</span><span data-if="cpp" style="display:none">MinScore</span><span data-if="com" style="display:none">MinScore</span><span data-if="dotnet" style="display:none">minScore</span><span data-if="python" style="display:none">min_score</span></code></i></a> is chosen, the faster the training is.  If the
initial components can be expected never to be occluded in the
training images, <a href="#MinScore"><i><code><span data-if="hdevelop" style="display:inline">MinScore</span><span data-if="c" style="display:none">MinScore</span><span data-if="cpp" style="display:none">MinScore</span><span data-if="com" style="display:none">MinScore</span><span data-if="dotnet" style="display:none">minScore</span><span data-if="python" style="display:none">min_score</span></code></i></a> may be set as high as 0.8 or even
0.9 (see <a href="find_shape_model.html"><code><span data-if="hdevelop" style="display:inline">find_shape_model</span><span data-if="c" style="display:none">find_shape_model</span><span data-if="cpp" style="display:none">FindShapeModel</span><span data-if="com" style="display:none">FindShapeModel</span><span data-if="dotnet" style="display:none">FindShapeModel</span><span data-if="python" style="display:none">find_shape_model</span></code></a>).
</p>
<p>By default, the components are searched only at points in which the
component lies completely within the respective training image.
This means that a component will not be found if it extends beyond
the borders of the image, even if it would achieve a score greater
than <a href="#MinScore"><i><code><span data-if="hdevelop" style="display:inline">MinScore</span><span data-if="c" style="display:none">MinScore</span><span data-if="cpp" style="display:none">MinScore</span><span data-if="com" style="display:none">MinScore</span><span data-if="dotnet" style="display:none">minScore</span><span data-if="python" style="display:none">min_score</span></code></i></a>.  This behavior can be changed with
<a href="set_system.html"><code><span data-if="hdevelop" style="display:inline">set_system('border_shape_models','true')</span><span data-if="c" style="display:none">set_system("border_shape_models","true")</span><span data-if="cpp" style="display:none">SetSystem("border_shape_models","true")</span><span data-if="com" style="display:none">SetSystem("border_shape_models","true")</span><span data-if="dotnet" style="display:none">SetSystem("border_shape_models","true")</span><span data-if="python" style="display:none">set_system("border_shape_models","true")</span></code></a>, which will cause
components that extend beyond the image border to be found if they
achieve a score greater than <a href="#MinScore"><i><code><span data-if="hdevelop" style="display:inline">MinScore</span><span data-if="c" style="display:none">MinScore</span><span data-if="cpp" style="display:none">MinScore</span><span data-if="com" style="display:none">MinScore</span><span data-if="dotnet" style="display:none">minScore</span><span data-if="python" style="display:none">min_score</span></code></i></a>.  Here, points lying
outside the image are regarded as being occluded, i.e., they lower
the score. It should be noted that the runtime of the training will
increase in this mode.
</p>
<p>When dealing with a high number of initial components and many
training images, the training may take a long time (up to several
minutes). In order to speed up the training it is possible to
restrict the search space for the single initial components in the
training images. For this, the poses of the initial components in
the model image are used as reference pose. The parameters
<a href="#SearchRowTol"><i><code><span data-if="hdevelop" style="display:inline">SearchRowTol</span><span data-if="c" style="display:none">SearchRowTol</span><span data-if="cpp" style="display:none">SearchRowTol</span><span data-if="com" style="display:none">SearchRowTol</span><span data-if="dotnet" style="display:none">searchRowTol</span><span data-if="python" style="display:none">search_row_tol</span></code></i></a> and <a href="#SearchColumnTol"><i><code><span data-if="hdevelop" style="display:inline">SearchColumnTol</span><span data-if="c" style="display:none">SearchColumnTol</span><span data-if="cpp" style="display:none">SearchColumnTol</span><span data-if="com" style="display:none">SearchColumnTol</span><span data-if="dotnet" style="display:none">searchColumnTol</span><span data-if="python" style="display:none">search_column_tol</span></code></i></a> specify the
position tolerance region relative to the reference position in
which the search is performed. Assume, for example, that the
position of an initial component in the model image is (100,200) and
<a href="#SearchRowTol"><i><code><span data-if="hdevelop" style="display:inline">SearchRowTol</span><span data-if="c" style="display:none">SearchRowTol</span><span data-if="cpp" style="display:none">SearchRowTol</span><span data-if="com" style="display:none">SearchRowTol</span><span data-if="dotnet" style="display:none">searchRowTol</span><span data-if="python" style="display:none">search_row_tol</span></code></i></a> is set to <i>20</i> and
<a href="#SearchColumnTol"><i><code><span data-if="hdevelop" style="display:inline">SearchColumnTol</span><span data-if="c" style="display:none">SearchColumnTol</span><span data-if="cpp" style="display:none">SearchColumnTol</span><span data-if="com" style="display:none">SearchColumnTol</span><span data-if="dotnet" style="display:none">searchColumnTol</span><span data-if="python" style="display:none">search_column_tol</span></code></i></a> is set to <i>10</i>. Then, this initial
component is searched in the training images only within the
axis-aligned rectangle that is determined by the upper left corner
(80,190) and the lower right corner (120,210).  The same holds for
the orientation angle range, which can be restricted by specifying
the angle tolerance <a href="#SearchAngleTol"><i><code><span data-if="hdevelop" style="display:inline">SearchAngleTol</span><span data-if="c" style="display:none">SearchAngleTol</span><span data-if="cpp" style="display:none">SearchAngleTol</span><span data-if="com" style="display:none">SearchAngleTol</span><span data-if="dotnet" style="display:none">searchAngleTol</span><span data-if="python" style="display:none">search_angle_tol</span></code></i></a> to the angle range of
[-<a href="#SearchAngleTol"><i><code><span data-if="hdevelop" style="display:inline">SearchAngleTol</span><span data-if="c" style="display:none">SearchAngleTol</span><span data-if="cpp" style="display:none">SearchAngleTol</span><span data-if="com" style="display:none">SearchAngleTol</span><span data-if="dotnet" style="display:none">searchAngleTol</span><span data-if="python" style="display:none">search_angle_tol</span></code></i></a>,+<a href="#SearchAngleTol"><i><code><span data-if="hdevelop" style="display:inline">SearchAngleTol</span><span data-if="c" style="display:none">SearchAngleTol</span><span data-if="cpp" style="display:none">SearchAngleTol</span><span data-if="com" style="display:none">SearchAngleTol</span><span data-if="dotnet" style="display:none">searchAngleTol</span><span data-if="python" style="display:none">search_angle_tol</span></code></i></a>]. Thus, it is
possible to considerably reduce the computational effort during the
training by an adequate acquisition of the training images. If one
of the three parameters is set to <i>-1</i>, no restriction of the
search space is applied in the corresponding dimension.
</p>
<p>The input parameters <a href="#ContrastLow"><i><code><span data-if="hdevelop" style="display:inline">ContrastLow</span><span data-if="c" style="display:none">ContrastLow</span><span data-if="cpp" style="display:none">ContrastLow</span><span data-if="com" style="display:none">ContrastLow</span><span data-if="dotnet" style="display:none">contrastLow</span><span data-if="python" style="display:none">contrast_low</span></code></i></a>, <a href="#ContrastHigh"><i><code><span data-if="hdevelop" style="display:inline">ContrastHigh</span><span data-if="c" style="display:none">ContrastHigh</span><span data-if="cpp" style="display:none">ContrastHigh</span><span data-if="com" style="display:none">ContrastHigh</span><span data-if="dotnet" style="display:none">contrastHigh</span><span data-if="python" style="display:none">contrast_high</span></code></i></a>,
<a href="#MinSize"><i><code><span data-if="hdevelop" style="display:inline">MinSize</span><span data-if="c" style="display:none">MinSize</span><span data-if="cpp" style="display:none">MinSize</span><span data-if="com" style="display:none">MinSize</span><span data-if="dotnet" style="display:none">minSize</span><span data-if="python" style="display:none">min_size</span></code></i></a>, <a href="#MinScore"><i><code><span data-if="hdevelop" style="display:inline">MinScore</span><span data-if="c" style="display:none">MinScore</span><span data-if="cpp" style="display:none">MinScore</span><span data-if="com" style="display:none">MinScore</span><span data-if="dotnet" style="display:none">minScore</span><span data-if="python" style="display:none">min_score</span></code></i></a>, <a href="#SearchRowTol"><i><code><span data-if="hdevelop" style="display:inline">SearchRowTol</span><span data-if="c" style="display:none">SearchRowTol</span><span data-if="cpp" style="display:none">SearchRowTol</span><span data-if="com" style="display:none">SearchRowTol</span><span data-if="dotnet" style="display:none">searchRowTol</span><span data-if="python" style="display:none">search_row_tol</span></code></i></a>,
<a href="#SearchColumnTol"><i><code><span data-if="hdevelop" style="display:inline">SearchColumnTol</span><span data-if="c" style="display:none">SearchColumnTol</span><span data-if="cpp" style="display:none">SearchColumnTol</span><span data-if="com" style="display:none">SearchColumnTol</span><span data-if="dotnet" style="display:none">searchColumnTol</span><span data-if="python" style="display:none">search_column_tol</span></code></i></a>, and <a href="#SearchAngleTol"><i><code><span data-if="hdevelop" style="display:inline">SearchAngleTol</span><span data-if="c" style="display:none">SearchAngleTol</span><span data-if="cpp" style="display:none">SearchAngleTol</span><span data-if="com" style="display:none">SearchAngleTol</span><span data-if="dotnet" style="display:none">searchAngleTol</span><span data-if="python" style="display:none">search_angle_tol</span></code></i></a> must either
contain one element, in which case the parameter is used for all
initial components, or must contain the same number of elements as
the initial components contained in <a href="#InitialComponents"><i><code><span data-if="hdevelop" style="display:inline">InitialComponents</span><span data-if="c" style="display:none">InitialComponents</span><span data-if="cpp" style="display:none">InitialComponents</span><span data-if="com" style="display:none">InitialComponents</span><span data-if="dotnet" style="display:none">initialComponents</span><span data-if="python" style="display:none">initial_components</span></code></i></a>, in
which case each parameter element refers to the corresponding
initial component in <a href="#InitialComponents"><i><code><span data-if="hdevelop" style="display:inline">InitialComponents</span><span data-if="c" style="display:none">InitialComponents</span><span data-if="cpp" style="display:none">InitialComponents</span><span data-if="com" style="display:none">InitialComponents</span><span data-if="dotnet" style="display:none">initialComponents</span><span data-if="python" style="display:none">initial_components</span></code></i></a>.
</p>
<p>The parameter <a href="#TrainingEmphasis"><i><code><span data-if="hdevelop" style="display:inline">TrainingEmphasis</span><span data-if="c" style="display:none">TrainingEmphasis</span><span data-if="cpp" style="display:none">TrainingEmphasis</span><span data-if="com" style="display:none">TrainingEmphasis</span><span data-if="dotnet" style="display:none">trainingEmphasis</span><span data-if="python" style="display:none">training_emphasis</span></code></i></a> offers another possibility
to influence the computation time of the training and to
simultaneously affect its robustness. If <a href="#TrainingEmphasis"><i><code><span data-if="hdevelop" style="display:inline">TrainingEmphasis</span><span data-if="c" style="display:none">TrainingEmphasis</span><span data-if="cpp" style="display:none">TrainingEmphasis</span><span data-if="com" style="display:none">TrainingEmphasis</span><span data-if="dotnet" style="display:none">trainingEmphasis</span><span data-if="python" style="display:none">training_emphasis</span></code></i></a>
is set to <i><span data-if="hdevelop" style="display:inline">'speed'</span><span data-if="c" style="display:none">"speed"</span><span data-if="cpp" style="display:none">"speed"</span><span data-if="com" style="display:none">"speed"</span><span data-if="dotnet" style="display:none">"speed"</span><span data-if="python" style="display:none">"speed"</span></i>, on the one hand the training is
comparatively fast, on the other hand it may happen in some cases
that some initial components are not found in the training images or
are found at a wrong pose.  Consequently, this would lead to an
incorrect computation of the rigid model components and their
relations. The poses of the found initial components in the
individual training images can be examined by using
<a href="get_training_components.html"><code><span data-if="hdevelop" style="display:inline">get_training_components</span><span data-if="c" style="display:none">get_training_components</span><span data-if="cpp" style="display:none">GetTrainingComponents</span><span data-if="com" style="display:none">GetTrainingComponents</span><span data-if="dotnet" style="display:none">GetTrainingComponents</span><span data-if="python" style="display:none">get_training_components</span></code></a>. If erroneous matches occur the
training should be restarted with <a href="#TrainingEmphasis"><i><code><span data-if="hdevelop" style="display:inline">TrainingEmphasis</span><span data-if="c" style="display:none">TrainingEmphasis</span><span data-if="cpp" style="display:none">TrainingEmphasis</span><span data-if="com" style="display:none">TrainingEmphasis</span><span data-if="dotnet" style="display:none">trainingEmphasis</span><span data-if="python" style="display:none">training_emphasis</span></code></i></a> set to
<i><span data-if="hdevelop" style="display:inline">'reliability'</span><span data-if="c" style="display:none">"reliability"</span><span data-if="cpp" style="display:none">"reliability"</span><span data-if="com" style="display:none">"reliability"</span><span data-if="dotnet" style="display:none">"reliability"</span><span data-if="python" style="display:none">"reliability"</span></i>. This results in a higher robustness at the
cost of a longer computation time.
</p>
<p>Furthermore, during the pose determination of the initial components
ambiguities may occur if the initial components are rotationally
symmetric or if several initial components are identical or at least
similar to each other. To solve the ambiguities, the most probable
pose is calculated for each initial component in each training
image. For this, the individual ambiguous poses are evaluated. The
pose of an initial component receives a good evaluation if the
relative pose of the initial component with respect to the other
initial components is similar to the corresponding relative pose in
the model image. The method to evaluate this similarity can be
chosen with <a href="#AmbiguityCriterion"><i><code><span data-if="hdevelop" style="display:inline">AmbiguityCriterion</span><span data-if="c" style="display:none">AmbiguityCriterion</span><span data-if="cpp" style="display:none">AmbiguityCriterion</span><span data-if="com" style="display:none">AmbiguityCriterion</span><span data-if="dotnet" style="display:none">ambiguityCriterion</span><span data-if="python" style="display:none">ambiguity_criterion</span></code></i></a>. In almost all cases the
best results are obtained with <i><span data-if="hdevelop" style="display:inline">'rigidity'</span><span data-if="c" style="display:none">"rigidity"</span><span data-if="cpp" style="display:none">"rigidity"</span><span data-if="com" style="display:none">"rigidity"</span><span data-if="dotnet" style="display:none">"rigidity"</span><span data-if="python" style="display:none">"rigidity"</span></i>, which assumes
the rigidity of the compound object. The more the rigidity of the
compound object is violated by the pose of the initial component,
the worse its evaluation is. In the case of <i><span data-if="hdevelop" style="display:inline">'distance'</span><span data-if="c" style="display:none">"distance"</span><span data-if="cpp" style="display:none">"distance"</span><span data-if="com" style="display:none">"distance"</span><span data-if="dotnet" style="display:none">"distance"</span><span data-if="python" style="display:none">"distance"</span></i>,
only the distance between the initial components is considered
during the evaluation.  Hence, the pose of the initial component
receives a good evaluation if its distances to the other initial
components is similar to the corresponding distances in the model
image. Accordingly, when choosing <i><span data-if="hdevelop" style="display:inline">'orientation'</span><span data-if="c" style="display:none">"orientation"</span><span data-if="cpp" style="display:none">"orientation"</span><span data-if="com" style="display:none">"orientation"</span><span data-if="dotnet" style="display:none">"orientation"</span><span data-if="python" style="display:none">"orientation"</span></i>, only the
relative orientation is considered during the evaluation. Finally,
the simultaneous consideration of distance and orientation can be
achieved by choosing <i><span data-if="hdevelop" style="display:inline">'distance_orientation'</span><span data-if="c" style="display:none">"distance_orientation"</span><span data-if="cpp" style="display:none">"distance_orientation"</span><span data-if="com" style="display:none">"distance_orientation"</span><span data-if="dotnet" style="display:none">"distance_orientation"</span><span data-if="python" style="display:none">"distance_orientation"</span></i>.  In contrast
to <i><span data-if="hdevelop" style="display:inline">'rigidity'</span><span data-if="c" style="display:none">"rigidity"</span><span data-if="cpp" style="display:none">"rigidity"</span><span data-if="com" style="display:none">"rigidity"</span><span data-if="dotnet" style="display:none">"rigidity"</span><span data-if="python" style="display:none">"rigidity"</span></i>, the relative pose of the initial components
is not considered when using <i><span data-if="hdevelop" style="display:inline">'distance_orientation'</span><span data-if="c" style="display:none">"distance_orientation"</span><span data-if="cpp" style="display:none">"distance_orientation"</span><span data-if="com" style="display:none">"distance_orientation"</span><span data-if="dotnet" style="display:none">"distance_orientation"</span><span data-if="python" style="display:none">"distance_orientation"</span></i>.
</p>
<p>The process of solving the ambiguities can be further influenced by
the parameter <a href="#MaxContourOverlap"><i><code><span data-if="hdevelop" style="display:inline">MaxContourOverlap</span><span data-if="c" style="display:none">MaxContourOverlap</span><span data-if="cpp" style="display:none">MaxContourOverlap</span><span data-if="com" style="display:none">MaxContourOverlap</span><span data-if="dotnet" style="display:none">maxContourOverlap</span><span data-if="python" style="display:none">max_contour_overlap</span></code></i></a>. This parameter describes
the extent by which the contours of two initial component matches
may overlap each other. Let the letters 'I' and 'T', for example, be
two initial components that should be searched in a training image
that shows the string 'IT'. Then, the initial component 'T' should
be found at its correct pose. In contrast, the initial component 'I'
will be found at its correct pose ('I') but also at the pose of the
'T' because of the similarity of the two components. To discard the
wrong match of the initial component 'I', an appropriate value for
<a href="#MaxContourOverlap"><i><code><span data-if="hdevelop" style="display:inline">MaxContourOverlap</span><span data-if="c" style="display:none">MaxContourOverlap</span><span data-if="cpp" style="display:none">MaxContourOverlap</span><span data-if="com" style="display:none">MaxContourOverlap</span><span data-if="dotnet" style="display:none">maxContourOverlap</span><span data-if="python" style="display:none">max_contour_overlap</span></code></i></a> can be chosen: If overlapping matches
should be tolerated, <a href="#MaxContourOverlap"><i><code><span data-if="hdevelop" style="display:inline">MaxContourOverlap</span><span data-if="c" style="display:none">MaxContourOverlap</span><span data-if="cpp" style="display:none">MaxContourOverlap</span><span data-if="com" style="display:none">MaxContourOverlap</span><span data-if="dotnet" style="display:none">maxContourOverlap</span><span data-if="python" style="display:none">max_contour_overlap</span></code></i></a> should be set to
<i>1</i>. If overlapping matches should be completely avoided,
<a href="#MaxContourOverlap"><i><code><span data-if="hdevelop" style="display:inline">MaxContourOverlap</span><span data-if="c" style="display:none">MaxContourOverlap</span><span data-if="cpp" style="display:none">MaxContourOverlap</span><span data-if="com" style="display:none">MaxContourOverlap</span><span data-if="dotnet" style="display:none">maxContourOverlap</span><span data-if="python" style="display:none">max_contour_overlap</span></code></i></a> should be set to <i>0</i>. By choosing
a value between <i>0</i> and <i>1</i>, the maximum percentage of
overlapping contour pixels can be adjusted.
</p>
<p>The decision which initial components can be clustered to rigid
model components is made based on the poses of the initial
components in the model image and in the training images. Two
initial components are merged if they do not show any relative
movement over all images. Assume that in the case of the above
mentioned switch the training image would show the same switch state
as the model image, the algorithm would merge the respective initial
components because it assumes that the entire switch is one rigid
model component. The extent by which initial components are merged
can be influenced with the parameter <a href="#ClusterThreshold"><i><code><span data-if="hdevelop" style="display:inline">ClusterThreshold</span><span data-if="c" style="display:none">ClusterThreshold</span><span data-if="cpp" style="display:none">ClusterThreshold</span><span data-if="com" style="display:none">ClusterThreshold</span><span data-if="dotnet" style="display:none">clusterThreshold</span><span data-if="python" style="display:none">cluster_threshold</span></code></i></a>. This
cluster threshold is based on the probability that two initial
components belong to the same rigid model component. Thus,
<a href="#ClusterThreshold"><i><code><span data-if="hdevelop" style="display:inline">ClusterThreshold</span><span data-if="c" style="display:none">ClusterThreshold</span><span data-if="cpp" style="display:none">ClusterThreshold</span><span data-if="com" style="display:none">ClusterThreshold</span><span data-if="dotnet" style="display:none">clusterThreshold</span><span data-if="python" style="display:none">cluster_threshold</span></code></i></a> describes the minimum probability which
two initial components must have in order to be merged.  Since the
threshold is based on a probability value, it must lie in the
interval between <i>0</i> and <i>1</i>. The greater the
threshold is chosen, the smaller the number of initial components
that are merged.  If a threshold of <i>0</i> is chosen, all
initial components are merged into one rigid component, while for a
threshold of <i>1</i> no merging is performed and each initial
component is adopted as one rigid model component.
</p>
<p>The final rigid model components are returned in
<a href="#ModelComponents"><i><code><span data-if="hdevelop" style="display:inline">ModelComponents</span><span data-if="c" style="display:none">ModelComponents</span><span data-if="cpp" style="display:none">ModelComponents</span><span data-if="com" style="display:none">ModelComponents</span><span data-if="dotnet" style="display:none">modelComponents</span><span data-if="python" style="display:none">model_components</span></code></i></a>.  Later, the index of a component region in
<a href="#ModelComponents"><i><code><span data-if="hdevelop" style="display:inline">ModelComponents</span><span data-if="c" style="display:none">ModelComponents</span><span data-if="cpp" style="display:none">ModelComponents</span><span data-if="com" style="display:none">ModelComponents</span><span data-if="dotnet" style="display:none">modelComponents</span><span data-if="python" style="display:none">model_components</span></code></i></a> is used to denote the model component.  The
poses of the components in the training images can be examined by
using <a href="get_training_components.html"><code><span data-if="hdevelop" style="display:inline">get_training_components</span><span data-if="c" style="display:none">get_training_components</span><span data-if="cpp" style="display:none">GetTrainingComponents</span><span data-if="com" style="display:none">GetTrainingComponents</span><span data-if="dotnet" style="display:none">GetTrainingComponents</span><span data-if="python" style="display:none">get_training_components</span></code></a>.
</p>
<p>After the determination of the model components their relative
movements are analyzed by determining the movement of one component
with respect to a second component for each pair of components. For
this, the components are referred to their reference points. The
reference point of a component is the center of gravity of its
contour region, which is returned in <a href="#ModelComponents"><i><code><span data-if="hdevelop" style="display:inline">ModelComponents</span><span data-if="c" style="display:none">ModelComponents</span><span data-if="cpp" style="display:none">ModelComponents</span><span data-if="com" style="display:none">ModelComponents</span><span data-if="dotnet" style="display:none">modelComponents</span><span data-if="python" style="display:none">model_components</span></code></i></a>. It
can be calculated by calling <a href="area_center.html"><code><span data-if="hdevelop" style="display:inline">area_center</span><span data-if="c" style="display:none">area_center</span><span data-if="cpp" style="display:none">AreaCenter</span><span data-if="com" style="display:none">AreaCenter</span><span data-if="dotnet" style="display:none">AreaCenter</span><span data-if="python" style="display:none">area_center</span></code></a>. Finally, the
relative movement is represented by the smallest enclosing rectangle
of arbitrary orientation of the reference point movement and by the
smallest enclosing angle interval of the relative orientation of the
second component over all images.  The determined relations can be
inspected by using <a href="get_component_relations.html"><code><span data-if="hdevelop" style="display:inline">get_component_relations</span><span data-if="c" style="display:none">get_component_relations</span><span data-if="cpp" style="display:none">GetComponentRelations</span><span data-if="com" style="display:none">GetComponentRelations</span><span data-if="dotnet" style="display:none">GetComponentRelations</span><span data-if="python" style="display:none">get_component_relations</span></code></a>.</p>
<h2 id="sec_execution">运行信息</h2>
<ul>
  <li>多线程类型:可重入(与非独占操作符并行运行)。</li>
<li>多线程作用域:全局(可以从任何线程调用)。</li>
  <li>未经并行化处理。</li>
</ul>
<p>This operator returns a handle. Note that the state of an instance of this handle type may be changed by specific operators even though the handle is used as an input parameter by those operators.</p>
<h2 id="sec_parameters">参数表</h2>
  <div class="par">
<div class="parhead">
<span id="ModelImage" class="parname"><b><code><span data-if="hdevelop" style="display:inline">ModelImage</span><span data-if="c" style="display:none">ModelImage</span><span data-if="cpp" style="display:none">ModelImage</span><span data-if="com" style="display:none">ModelImage</span><span data-if="dotnet" style="display:none">modelImage</span><span data-if="python" style="display:none">model_image</span></code></b> (input_object)  </span><span>(multichannel-)image <code>→</code> <span data-if="hdevelop" style="display:inline">object</span><span data-if="dotnet" style="display:none"><a href="HImage.html">HImage</a></span><span data-if="python" style="display:none">HObject</span><span data-if="cpp" style="display:none"><a href="HImage.html">HImage</a></span><span data-if="c" style="display:none">Hobject</span> (byte / uint2)</span>
</div>
<p class="pardesc">Input image from which the shape models of the initial
components should be created.</p>
</div>
  <div class="par">
<div class="parhead">
<span id="InitialComponents" class="parname"><b><code><span data-if="hdevelop" style="display:inline">InitialComponents</span><span data-if="c" style="display:none">InitialComponents</span><span data-if="cpp" style="display:none">InitialComponents</span><span data-if="com" style="display:none">InitialComponents</span><span data-if="dotnet" style="display:none">initialComponents</span><span data-if="python" style="display:none">initial_components</span></code></b> (input_object)  </span><span>region-array <code>→</code> <span data-if="hdevelop" style="display:inline">object</span><span data-if="dotnet" style="display:none"><a href="HRegion.html">HRegion</a></span><span data-if="python" style="display:none">HObject</span><span data-if="cpp" style="display:none"><a href="HRegion.html">HRegion</a></span><span data-if="c" style="display:none">Hobject</span></span>
</div>
<p class="pardesc">Contour regions or enclosing regions of the
initial components.</p>
</div>
  <div class="par">
<div class="parhead">
<span id="TrainingImages" class="parname"><b><code><span data-if="hdevelop" style="display:inline">TrainingImages</span><span data-if="c" style="display:none">TrainingImages</span><span data-if="cpp" style="display:none">TrainingImages</span><span data-if="com" style="display:none">TrainingImages</span><span data-if="dotnet" style="display:none">trainingImages</span><span data-if="python" style="display:none">training_images</span></code></b> (input_object)  </span><span>(multichannel-)image(-array) <code>→</code> <span data-if="hdevelop" style="display:inline">object</span><span data-if="dotnet" style="display:none"><a href="HImage.html">HImage</a></span><span data-if="python" style="display:none">HObject</span><span data-if="cpp" style="display:none"><a href="HImage.html">HImage</a></span><span data-if="c" style="display:none">Hobject</span> (byte / uint2)</span>
</div>
<p class="pardesc">Training images that are used for training the
model components.</p>
</div>
  <div class="par">
<div class="parhead">
<span id="ModelComponents" class="parname"><b><code><span data-if="hdevelop" style="display:inline">ModelComponents</span><span data-if="c" style="display:none">ModelComponents</span><span data-if="cpp" style="display:none">ModelComponents</span><span data-if="com" style="display:none">ModelComponents</span><span data-if="dotnet" style="display:none">modelComponents</span><span data-if="python" style="display:none">model_components</span></code></b> (output_object)  </span><span>region(-array) <code>→</code> <span data-if="hdevelop" style="display:inline">object</span><span data-if="dotnet" style="display:none"><a href="HRegion.html">HRegion</a></span><span data-if="python" style="display:none">HObject</span><span data-if="cpp" style="display:none"><a href="HRegion.html">HRegion</a></span><span data-if="c" style="display:none">Hobject *</span></span>
</div>
<p class="pardesc">Contour regions of rigid model components.</p>
</div>
  <div class="par">
<div class="parhead">
<span id="ContrastLow" class="parname"><b><code><span data-if="hdevelop" style="display:inline">ContrastLow</span><span data-if="c" style="display:none">ContrastLow</span><span data-if="cpp" style="display:none">ContrastLow</span><span data-if="com" style="display:none">ContrastLow</span><span data-if="dotnet" style="display:none">contrastLow</span><span data-if="python" style="display:none">contrast_low</span></code></b> (input_control)  </span><span>integer(-array) <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">MaybeSequence[Union[int, str]]</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (integer / </span><span data-if="hdevelop" style="display:inline">string)</span><span data-if="dotnet" style="display:none"> (<i>int</i> / </span><span data-if="dotnet" style="display:none">long / </span><span data-if="dotnet" style="display:none">string)</span><span data-if="cpp" style="display:none"> (<i>Hlong</i> / </span><span data-if="cpp" style="display:none">HString)</span><span data-if="c" style="display:none"> (<i>Hlong</i> / </span><span data-if="c" style="display:none">char*)</span></span>
</div>
<p class="pardesc">Lower hysteresis threshold for the contrast of the
initial components in the image.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>
    <span data-if="hdevelop" style="display:inline">'auto'</span>
    <span data-if="c" style="display:none">"auto"</span>
    <span data-if="cpp" style="display:none">"auto"</span>
    <span data-if="com" style="display:none">"auto"</span>
    <span data-if="dotnet" style="display:none">"auto"</span>
    <span data-if="python" style="display:none">"auto"</span>
</p>
<p class="pardesc"><span class="parcat">Suggested values:
      </span><span data-if="hdevelop" style="display:inline">'auto'</span><span data-if="c" style="display:none">"auto"</span><span data-if="cpp" style="display:none">"auto"</span><span data-if="com" style="display:none">"auto"</span><span data-if="dotnet" style="display:none">"auto"</span><span data-if="python" style="display:none">"auto"</span>, 10, 20, 30, 40, 60, 80, 100, 120, 140, 160</p>
<p class="pardesc"><span class="parcat">Restriction:
      </span><code>ContrastLow &gt; 0</code></p>
</div>
  <div class="par">
<div class="parhead">
<span id="ContrastHigh" class="parname"><b><code><span data-if="hdevelop" style="display:inline">ContrastHigh</span><span data-if="c" style="display:none">ContrastHigh</span><span data-if="cpp" style="display:none">ContrastHigh</span><span data-if="com" style="display:none">ContrastHigh</span><span data-if="dotnet" style="display:none">contrastHigh</span><span data-if="python" style="display:none">contrast_high</span></code></b> (input_control)  </span><span>integer(-array) <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">MaybeSequence[Union[int, str]]</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (integer / </span><span data-if="hdevelop" style="display:inline">string)</span><span data-if="dotnet" style="display:none"> (<i>int</i> / </span><span data-if="dotnet" style="display:none">long / </span><span data-if="dotnet" style="display:none">string)</span><span data-if="cpp" style="display:none"> (<i>Hlong</i> / </span><span data-if="cpp" style="display:none">HString)</span><span data-if="c" style="display:none"> (<i>Hlong</i> / </span><span data-if="c" style="display:none">char*)</span></span>
</div>
<p class="pardesc">Upper hysteresis threshold for the contrast of the
initial components in the image.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>
    <span data-if="hdevelop" style="display:inline">'auto'</span>
    <span data-if="c" style="display:none">"auto"</span>
    <span data-if="cpp" style="display:none">"auto"</span>
    <span data-if="com" style="display:none">"auto"</span>
    <span data-if="dotnet" style="display:none">"auto"</span>
    <span data-if="python" style="display:none">"auto"</span>
</p>
<p class="pardesc"><span class="parcat">Suggested values:
      </span><span data-if="hdevelop" style="display:inline">'auto'</span><span data-if="c" style="display:none">"auto"</span><span data-if="cpp" style="display:none">"auto"</span><span data-if="com" style="display:none">"auto"</span><span data-if="dotnet" style="display:none">"auto"</span><span data-if="python" style="display:none">"auto"</span>, 10, 20, 30, 40, 60, 80, 100, 120, 140, 160</p>
<p class="pardesc"><span class="parcat">Restriction:
      </span><code>ContrastHigh &gt; 0 &amp;&amp; ContrastHigh &gt;= ContrastLow</code></p>
</div>
  <div class="par">
<div class="parhead">
<span id="MinSize" class="parname"><b><code><span data-if="hdevelop" style="display:inline">MinSize</span><span data-if="c" style="display:none">MinSize</span><span data-if="cpp" style="display:none">MinSize</span><span data-if="com" style="display:none">MinSize</span><span data-if="dotnet" style="display:none">minSize</span><span data-if="python" style="display:none">min_size</span></code></b> (input_control)  </span><span>integer(-array) <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">MaybeSequence[Union[int, str]]</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (integer / </span><span data-if="hdevelop" style="display:inline">string)</span><span data-if="dotnet" style="display:none"> (<i>int</i> / </span><span data-if="dotnet" style="display:none">long / </span><span data-if="dotnet" style="display:none">string)</span><span data-if="cpp" style="display:none"> (<i>Hlong</i> / </span><span data-if="cpp" style="display:none">HString)</span><span data-if="c" style="display:none"> (<i>Hlong</i> / </span><span data-if="c" style="display:none">char*)</span></span>
</div>
<p class="pardesc">Minimum size of connected contour regions.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>
    <span data-if="hdevelop" style="display:inline">'auto'</span>
    <span data-if="c" style="display:none">"auto"</span>
    <span data-if="cpp" style="display:none">"auto"</span>
    <span data-if="com" style="display:none">"auto"</span>
    <span data-if="dotnet" style="display:none">"auto"</span>
    <span data-if="python" style="display:none">"auto"</span>
</p>
<p class="pardesc"><span class="parcat">Suggested values:
      </span><span data-if="hdevelop" style="display:inline">'auto'</span><span data-if="c" style="display:none">"auto"</span><span data-if="cpp" style="display:none">"auto"</span><span data-if="com" style="display:none">"auto"</span><span data-if="dotnet" style="display:none">"auto"</span><span data-if="python" style="display:none">"auto"</span>, 0, 5, 10, 20, 30, 40</p>
<p class="pardesc"><span class="parcat">Restriction:
      </span><code>MinSize &gt;= 0</code></p>
</div>
  <div class="par">
<div class="parhead">
<span id="MinScore" class="parname"><b><code><span data-if="hdevelop" style="display:inline">MinScore</span><span data-if="c" style="display:none">MinScore</span><span data-if="cpp" style="display:none">MinScore</span><span data-if="com" style="display:none">MinScore</span><span data-if="dotnet" style="display:none">minScore</span><span data-if="python" style="display:none">min_score</span></code></b> (input_control)  </span><span>real(-array) <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">MaybeSequence[float]</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (real)</span><span data-if="dotnet" style="display:none"> (<i>double</i>)</span><span data-if="cpp" style="display:none"> (<i>double</i>)</span><span data-if="c" style="display:none"> (<i>double</i>)</span></span>
</div>
<p class="pardesc">Minimum score of the instances of the initial
components to be found.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>0.5</p>
<p class="pardesc"><span class="parcat">Suggested values:
      </span>0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0</p>
<p class="pardesc"><span class="parcat">Minimum increment:
      </span>0.01</p>
<p class="pardesc"><span class="parcat">Recommended increment:
      </span>0.05</p>
<p class="pardesc"><span class="parcat">Restriction:
      </span><code>0 &lt;= MinScore &amp;&amp; MinScore &lt;= 1</code></p>
</div>
  <div class="par">
<div class="parhead">
<span id="SearchRowTol" class="parname"><b><code><span data-if="hdevelop" style="display:inline">SearchRowTol</span><span data-if="c" style="display:none">SearchRowTol</span><span data-if="cpp" style="display:none">SearchRowTol</span><span data-if="com" style="display:none">SearchRowTol</span><span data-if="dotnet" style="display:none">searchRowTol</span><span data-if="python" style="display:none">search_row_tol</span></code></b> (input_control)  </span><span>integer(-array) <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">MaybeSequence[int]</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (integer)</span><span data-if="dotnet" style="display:none"> (<i>int</i> / </span><span data-if="dotnet" style="display:none">long)</span><span data-if="cpp" style="display:none"> (<i>Hlong</i>)</span><span data-if="c" style="display:none"> (<i>Hlong</i>)</span></span>
</div>
<p class="pardesc">Search tolerance in row direction.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>-1</p>
<p class="pardesc"><span class="parcat">Suggested values:
      </span>0, 10, 20, 30, 50, 100</p>
<p class="pardesc"><span class="parcat">Restriction:
      </span><code>SearchRowTol == -1 || SearchColumnTol &gt;= 0</code></p>
</div>
  <div class="par">
<div class="parhead">
<span id="SearchColumnTol" class="parname"><b><code><span data-if="hdevelop" style="display:inline">SearchColumnTol</span><span data-if="c" style="display:none">SearchColumnTol</span><span data-if="cpp" style="display:none">SearchColumnTol</span><span data-if="com" style="display:none">SearchColumnTol</span><span data-if="dotnet" style="display:none">searchColumnTol</span><span data-if="python" style="display:none">search_column_tol</span></code></b> (input_control)  </span><span>integer(-array) <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">MaybeSequence[int]</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (integer)</span><span data-if="dotnet" style="display:none"> (<i>int</i> / </span><span data-if="dotnet" style="display:none">long)</span><span data-if="cpp" style="display:none"> (<i>Hlong</i>)</span><span data-if="c" style="display:none"> (<i>Hlong</i>)</span></span>
</div>
<p class="pardesc">Search tolerance in column direction.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>-1</p>
<p class="pardesc"><span class="parcat">Suggested values:
      </span>0, 10, 20, 30, 50, 100</p>
<p class="pardesc"><span class="parcat">Restriction:
      </span><code>SearchColumnTol == -1 || SearchColumnTol &gt;= 0</code></p>
</div>
  <div class="par">
<div class="parhead">
<span id="SearchAngleTol" class="parname"><b><code><span data-if="hdevelop" style="display:inline">SearchAngleTol</span><span data-if="c" style="display:none">SearchAngleTol</span><span data-if="cpp" style="display:none">SearchAngleTol</span><span data-if="com" style="display:none">SearchAngleTol</span><span data-if="dotnet" style="display:none">searchAngleTol</span><span data-if="python" style="display:none">search_angle_tol</span></code></b> (input_control)  </span><span>angle.rad(-array) <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">MaybeSequence[float]</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (real)</span><span data-if="dotnet" style="display:none"> (<i>double</i>)</span><span data-if="cpp" style="display:none"> (<i>double</i>)</span><span data-if="c" style="display:none"> (<i>double</i>)</span></span>
</div>
<p class="pardesc">Angle search tolerance.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>-1</p>
<p class="pardesc"><span class="parcat">Suggested values:
      </span>0.0, 0.17, 0.39, 0.78, 1.57</p>
<p class="pardesc"><span class="parcat">Restriction:
      </span><code>SearchAngleTol == -1 || SearchAngleTol &gt;= 0</code></p>
</div>
  <div class="par">
<div class="parhead">
<span id="TrainingEmphasis" class="parname"><b><code><span data-if="hdevelop" style="display:inline">TrainingEmphasis</span><span data-if="c" style="display:none">TrainingEmphasis</span><span data-if="cpp" style="display:none">TrainingEmphasis</span><span data-if="com" style="display:none">TrainingEmphasis</span><span data-if="dotnet" style="display:none">trainingEmphasis</span><span data-if="python" style="display:none">training_emphasis</span></code></b> (input_control)  </span><span>string <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">str</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (string)</span><span data-if="dotnet" style="display:none"> (<i>string</i>)</span><span data-if="cpp" style="display:none"> (<i>HString</i>)</span><span data-if="c" style="display:none"> (<i>char*</i>)</span></span>
</div>
<p class="pardesc">Decision whether the training emphasis should lie on
a fast computation or on a high robustness.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>
    <span data-if="hdevelop" style="display:inline">'speed'</span>
    <span data-if="c" style="display:none">"speed"</span>
    <span data-if="cpp" style="display:none">"speed"</span>
    <span data-if="com" style="display:none">"speed"</span>
    <span data-if="dotnet" style="display:none">"speed"</span>
    <span data-if="python" style="display:none">"speed"</span>
</p>
<p class="pardesc"><span class="parcat">List of values:
      </span><span data-if="hdevelop" style="display:inline">'reliability'</span><span data-if="c" style="display:none">"reliability"</span><span data-if="cpp" style="display:none">"reliability"</span><span data-if="com" style="display:none">"reliability"</span><span data-if="dotnet" style="display:none">"reliability"</span><span data-if="python" style="display:none">"reliability"</span>, <span data-if="hdevelop" style="display:inline">'speed'</span><span data-if="c" style="display:none">"speed"</span><span data-if="cpp" style="display:none">"speed"</span><span data-if="com" style="display:none">"speed"</span><span data-if="dotnet" style="display:none">"speed"</span><span data-if="python" style="display:none">"speed"</span></p>
</div>
  <div class="par">
<div class="parhead">
<span id="AmbiguityCriterion" class="parname"><b><code><span data-if="hdevelop" style="display:inline">AmbiguityCriterion</span><span data-if="c" style="display:none">AmbiguityCriterion</span><span data-if="cpp" style="display:none">AmbiguityCriterion</span><span data-if="com" style="display:none">AmbiguityCriterion</span><span data-if="dotnet" style="display:none">ambiguityCriterion</span><span data-if="python" style="display:none">ambiguity_criterion</span></code></b> (input_control)  </span><span>string <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">str</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (string)</span><span data-if="dotnet" style="display:none"> (<i>string</i>)</span><span data-if="cpp" style="display:none"> (<i>HString</i>)</span><span data-if="c" style="display:none"> (<i>char*</i>)</span></span>
</div>
<p class="pardesc">Criterion for solving ambiguous matches of the initial
components in the training images.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>
    <span data-if="hdevelop" style="display:inline">'rigidity'</span>
    <span data-if="c" style="display:none">"rigidity"</span>
    <span data-if="cpp" style="display:none">"rigidity"</span>
    <span data-if="com" style="display:none">"rigidity"</span>
    <span data-if="dotnet" style="display:none">"rigidity"</span>
    <span data-if="python" style="display:none">"rigidity"</span>
</p>
<p class="pardesc"><span class="parcat">List of values:
      </span><span data-if="hdevelop" style="display:inline">'distance'</span><span data-if="c" style="display:none">"distance"</span><span data-if="cpp" style="display:none">"distance"</span><span data-if="com" style="display:none">"distance"</span><span data-if="dotnet" style="display:none">"distance"</span><span data-if="python" style="display:none">"distance"</span>, <span data-if="hdevelop" style="display:inline">'distance_orientation'</span><span data-if="c" style="display:none">"distance_orientation"</span><span data-if="cpp" style="display:none">"distance_orientation"</span><span data-if="com" style="display:none">"distance_orientation"</span><span data-if="dotnet" style="display:none">"distance_orientation"</span><span data-if="python" style="display:none">"distance_orientation"</span>, <span data-if="hdevelop" style="display:inline">'orientation'</span><span data-if="c" style="display:none">"orientation"</span><span data-if="cpp" style="display:none">"orientation"</span><span data-if="com" style="display:none">"orientation"</span><span data-if="dotnet" style="display:none">"orientation"</span><span data-if="python" style="display:none">"orientation"</span>, <span data-if="hdevelop" style="display:inline">'rigidity'</span><span data-if="c" style="display:none">"rigidity"</span><span data-if="cpp" style="display:none">"rigidity"</span><span data-if="com" style="display:none">"rigidity"</span><span data-if="dotnet" style="display:none">"rigidity"</span><span data-if="python" style="display:none">"rigidity"</span></p>
</div>
  <div class="par">
<div class="parhead">
<span id="MaxContourOverlap" class="parname"><b><code><span data-if="hdevelop" style="display:inline">MaxContourOverlap</span><span data-if="c" style="display:none">MaxContourOverlap</span><span data-if="cpp" style="display:none">MaxContourOverlap</span><span data-if="com" style="display:none">MaxContourOverlap</span><span data-if="dotnet" style="display:none">maxContourOverlap</span><span data-if="python" style="display:none">max_contour_overlap</span></code></b> (input_control)  </span><span>real <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">float</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (real)</span><span data-if="dotnet" style="display:none"> (<i>double</i>)</span><span data-if="cpp" style="display:none"> (<i>double</i>)</span><span data-if="c" style="display:none"> (<i>double</i>)</span></span>
</div>
<p class="pardesc">Maximum contour overlap of the found initial components
in a training image.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>0.2</p>
<p class="pardesc"><span class="parcat">Suggested values:
      </span>0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0</p>
<p class="pardesc"><span class="parcat">Minimum increment:
      </span>0.01</p>
<p class="pardesc"><span class="parcat">Recommended increment:
      </span>0.05</p>
<p class="pardesc"><span class="parcat">Restriction:
      </span><code>0 &lt;= MaxContourOverlap &amp;&amp; MaxContourOverlap &lt;= 1</code></p>
</div>
  <div class="par">
<div class="parhead">
<span id="ClusterThreshold" class="parname"><b><code><span data-if="hdevelop" style="display:inline">ClusterThreshold</span><span data-if="c" style="display:none">ClusterThreshold</span><span data-if="cpp" style="display:none">ClusterThreshold</span><span data-if="com" style="display:none">ClusterThreshold</span><span data-if="dotnet" style="display:none">clusterThreshold</span><span data-if="python" style="display:none">cluster_threshold</span></code></b> (input_control)  </span><span>real <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">float</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (real)</span><span data-if="dotnet" style="display:none"> (<i>double</i>)</span><span data-if="cpp" style="display:none"> (<i>double</i>)</span><span data-if="c" style="display:none"> (<i>double</i>)</span></span>
</div>
<p class="pardesc">Threshold for clustering the initial components.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>0.5</p>
<p class="pardesc"><span class="parcat">Suggested values:
      </span>0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0</p>
<p class="pardesc"><span class="parcat">Restriction:
      </span><code>0 &lt;= ClusterThreshold &amp;&amp; ClusterThreshold &lt;= 1</code></p>
</div>
  <div class="par">
<div class="parhead">
<span id="ComponentTrainingID" class="parname"><b><code><span data-if="hdevelop" style="display:inline">ComponentTrainingID</span><span data-if="c" style="display:none">ComponentTrainingID</span><span data-if="cpp" style="display:none">ComponentTrainingID</span><span data-if="com" style="display:none">ComponentTrainingID</span><span data-if="dotnet" style="display:none">componentTrainingID</span><span data-if="python" style="display:none">component_training_id</span></code></b> (output_control)  </span><span>component_training <code>→</code> <span data-if="dotnet" style="display:none"><a href="HComponentTraining.html">HComponentTraining</a>, </span><span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">HHandle</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (handle)</span><span data-if="dotnet" style="display:none"> (<i>IntPtr</i>)</span><span data-if="cpp" style="display:none"> (<i>HHandle</i>)</span><span data-if="c" style="display:none"> (<i>handle</i>)</span></span>
</div>
<p class="pardesc">Handle of the training result.</p>
</div>
<h2 id="sec_example_all">例程 (HDevelop)</h2>
<pre class="example">
* Get the model image.
read_image (ModelImage, 'model_image.tif')
* Define the regions for the initial components.
gen_rectangle2 (InitialComponentRegions, 212, 233, 0.62, 167, 29)
gen_rectangle2 (Rectangle2, 298, 363, 1.17, 162, 34)
gen_rectangle2 (Rectangle3, 63, 444, -0.26, 50, 27)
gen_rectangle2 (Rectangle4, 120, 473, 0, 33, 20)
concat_obj (InitialComponentRegions, Rectangle2, InitialComponentRegions)
concat_obj (InitialComponentRegions, Rectangle3, InitialComponentRegions)
concat_obj (InitialComponentRegions, Rectangle4, InitialComponentRegions)
* Get the training images.
gen_empty_obj (TrainingImages)
for i := 1 to 4 by 1
    read_image (TrainingImage, 'training_image-'+i+'.tif')
    concat_obj (TrainingImages, TrainingImage, TrainingImages)
endfor
* Extract the model components and train the relations.
train_model_components (ModelImage, InitialComponentRegions, \
                        TrainingImages, ModelComponents, 22, 60, 30, 0.6, \
                        0, 0, rad(60), 'speed', 'rigidity', 0.2, 0.4, \
                        ComponentTrainingID)
</pre>
<h2 id="sec_result">结果</h2>
<p>If the parameter values are correct, 该算子
<code><span data-if="hdevelop" style="display:inline">train_model_components</span><span data-if="c" style="display:none">train_model_components</span><span data-if="cpp" style="display:none">TrainModelComponents</span><span data-if="com" style="display:none">TrainModelComponents</span><span data-if="dotnet" style="display:none">TrainModelComponents</span><span data-if="python" style="display:none">train_model_components</span></code> 返回值 <TT>2</TT> (
      <TT>H_MSG_TRUE</TT>)
    .  If the input is
empty (no input images are available) the behavior can be set via
<a href="set_system.html"><code><span data-if="hdevelop" style="display:inline">set_system('no_object_result',&lt;Result&gt;)</span><span data-if="c" style="display:none">set_system("no_object_result",&lt;Result&gt;)</span><span data-if="cpp" style="display:none">SetSystem("no_object_result",&lt;Result&gt;)</span><span data-if="com" style="display:none">SetSystem("no_object_result",&lt;Result&gt;)</span><span data-if="dotnet" style="display:none">SetSystem("no_object_result",&lt;Result&gt;)</span><span data-if="python" style="display:none">set_system("no_object_result",&lt;Result&gt;)</span></code></a>.  If necessary, an
exception is raised.</p>
<h2 id="sec_predecessors">可能的前置算子</h2>
<p>
<code><a href="gen_initial_components.html"><span data-if="hdevelop" style="display:inline">gen_initial_components</span><span data-if="c" style="display:none">gen_initial_components</span><span data-if="cpp" style="display:none">GenInitialComponents</span><span data-if="com" style="display:none">GenInitialComponents</span><span data-if="dotnet" style="display:none">GenInitialComponents</span><span data-if="python" style="display:none">gen_initial_components</span></a></code>
</p>
<h2 id="sec_successors">可能的后置算子</h2>
<p>
<code><a href="inspect_clustered_components.html"><span data-if="hdevelop" style="display:inline">inspect_clustered_components</span><span data-if="c" style="display:none">inspect_clustered_components</span><span data-if="cpp" style="display:none">InspectClusteredComponents</span><span data-if="com" style="display:none">InspectClusteredComponents</span><span data-if="dotnet" style="display:none">InspectClusteredComponents</span><span data-if="python" style="display:none">inspect_clustered_components</span></a></code>, 
<code><a href="cluster_model_components.html"><span data-if="hdevelop" style="display:inline">cluster_model_components</span><span data-if="c" style="display:none">cluster_model_components</span><span data-if="cpp" style="display:none">ClusterModelComponents</span><span data-if="com" style="display:none">ClusterModelComponents</span><span data-if="dotnet" style="display:none">ClusterModelComponents</span><span data-if="python" style="display:none">cluster_model_components</span></a></code>, 
<code><a href="modify_component_relations.html"><span data-if="hdevelop" style="display:inline">modify_component_relations</span><span data-if="c" style="display:none">modify_component_relations</span><span data-if="cpp" style="display:none">ModifyComponentRelations</span><span data-if="com" style="display:none">ModifyComponentRelations</span><span data-if="dotnet" style="display:none">ModifyComponentRelations</span><span data-if="python" style="display:none">modify_component_relations</span></a></code>, 
<code><a href="write_training_components.html"><span data-if="hdevelop" style="display:inline">write_training_components</span><span data-if="c" style="display:none">write_training_components</span><span data-if="cpp" style="display:none">WriteTrainingComponents</span><span data-if="com" style="display:none">WriteTrainingComponents</span><span data-if="dotnet" style="display:none">WriteTrainingComponents</span><span data-if="python" style="display:none">write_training_components</span></a></code>, 
<code><a href="get_training_components.html"><span data-if="hdevelop" style="display:inline">get_training_components</span><span data-if="c" style="display:none">get_training_components</span><span data-if="cpp" style="display:none">GetTrainingComponents</span><span data-if="com" style="display:none">GetTrainingComponents</span><span data-if="dotnet" style="display:none">GetTrainingComponents</span><span data-if="python" style="display:none">get_training_components</span></a></code>, 
<code><a href="get_component_relations.html"><span data-if="hdevelop" style="display:inline">get_component_relations</span><span data-if="c" style="display:none">get_component_relations</span><span data-if="cpp" style="display:none">GetComponentRelations</span><span data-if="com" style="display:none">GetComponentRelations</span><span data-if="dotnet" style="display:none">GetComponentRelations</span><span data-if="python" style="display:none">get_component_relations</span></a></code>, 
<code><a href="create_trained_component_model.html"><span data-if="hdevelop" style="display:inline">create_trained_component_model</span><span data-if="c" style="display:none">create_trained_component_model</span><span data-if="cpp" style="display:none">CreateTrainedComponentModel</span><span data-if="com" style="display:none">CreateTrainedComponentModel</span><span data-if="dotnet" style="display:none">CreateTrainedComponentModel</span><span data-if="python" style="display:none">create_trained_component_model</span></a></code>, 
<code><a href="clear_training_components.html"><span data-if="hdevelop" style="display:inline">clear_training_components</span><span data-if="c" style="display:none">clear_training_components</span><span data-if="cpp" style="display:none">ClearTrainingComponents</span><span data-if="com" style="display:none">ClearTrainingComponents</span><span data-if="dotnet" style="display:none">ClearTrainingComponents</span><span data-if="python" style="display:none">clear_training_components</span></a></code>
</p>
<h2 id="sec_see">参考其它</h2>
<p>
<code><a href="create_trained_component_model.html"><span data-if="hdevelop" style="display:inline">create_trained_component_model</span><span data-if="c" style="display:none">create_trained_component_model</span><span data-if="cpp" style="display:none">CreateTrainedComponentModel</span><span data-if="com" style="display:none">CreateTrainedComponentModel</span><span data-if="dotnet" style="display:none">CreateTrainedComponentModel</span><span data-if="python" style="display:none">create_trained_component_model</span></a></code>
</p>
<h2 id="sec_module">模块</h2>
<p>
Matching</p>
<!--OP_REF_FOOTER_START-->
<hr>
<div class="indexlink">
<a href="index_classes.html"><span data-if="dotnet" style="display:none;">类别</span><span data-if="cpp" style="display:none;">类别</span></a><span data-if="dotnet" style="display:none;"> | </span><span data-if="cpp" style="display:none;"> | </span><a href="index_by_name.html">算子列表</a>
</div>
<div class="footer">
<div class="copyright">HALCON算子参考手册 Copyright © 2015-2023 51Halcon</div>
</div>
</div>
</body>
</html>
